int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION] [FILE]...\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Concatenate FILE(s), or standard input, to standard output.\n\
\n\
-b, --number-nonblank number nonblank output lines\n\
--version output version information and exit\n\
\n\
With no FILE, or when FILE is -, read standard input.\n\
-");
+"));
}
exit (status);
}
/* Get device, i-node number, and optimal blocksize of output. */
if (fstat (output_desc, &stat_buf) < 0)
- error (1, errno, "standard output");
+ error (1, errno, _("standard output"));
outsize = ST_BLKSIZE (stat_buf);
/* Input file can be output file for non-regular files.
if (check_redirection
&& stat_buf.st_dev == out_dev && stat_buf.st_ino == out_ino)
{
- error (0, 0, "%s: input file is output file", infile);
+ error (0, 0, _("%s: input file is output file"), infile);
exit_stat = 1;
goto contin;
}
if (have_read_stdin && close (0) < 0)
error (1, errno, "-");
if (close (1) < 0)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
exit (exit_stat);
}
/* Write this block out. */
if (full_write (output_desc, buf, n_read) < 0)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
}
}
\f
do
{
if (full_write (output_desc, wp, outsize) < 0)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
wp += outsize;
}
while (bpout - wp >= outsize);
use_fionread = 0;
else
{
- error (0, errno, "cannot do ioctl on `%s'", infile);
+ error (0, errno, _("cannot do ioctl on `%s'"), infile);
exit_stat = 1;
newlines2 = newlines;
return;
int n_write = bpout - outbuf;
if (full_write (output_desc, outbuf, n_write) < 0)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
bpout = outbuf;
}
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... [FILE]...\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Print CRC checksum and byte counts of each FILE.\n\
\n\
--help display this help and exit\n\
--version output version information and exit\n\
-");
+"));
}
exit (status);
}
usage (int status)
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... LEFT_FILE RIGHT_FILE\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Compare sorted files LEFT_FILE and RIGHT_FILE line by line.\n\
\n\
-1 suppress lines unique to left file\n\
-3 suppress lines unique to both files\n\
--help display this help and exit\n\
--version output version information and exit\n\
-");
+"));
}
exit (status);
}
}
if (ferror (stdout) || fclose (stdout) == EOF)
{
- error (0, errno, "write error");
+ error (0, errno, _("write error"));
ret = 1;
}
return ret;
p = malloc (n);
if (p == NULL)
{
- error (0, 0, "virtual memory exhausted");
+ error (0, 0, _("virtual memory exhausted"));
cleanup ();
}
return p;
p = realloc (p, n);
if (p == NULL)
{
- error (0, 0, "virtual memory exhausted");
+ error (0, 0, _("virtual memory exhausted"));
cleanup ();
}
return p;
if (bytes_read < 0)
{
- error (0, errno, "read error");
+ error (0, errno, _("read error"));
cleanup ();
}
get_first_line_in_buffer ()
{
if (head == NULL && !load_buffer ())
- error (1, errno, "input disappeared");
+ error (1, errno, _("input disappeared"));
return head->first_available;
}
if (first_line > last_line)
{
- error (0, 0, "%s: line number out of range", global_argv[argnum]);
+ error (0, 0, _("%s: line number out of range"), global_argv[argnum]);
cleanup ();
}
line = remove_line ();
if (line == NULL)
{
- error (0, 0, "%s: line number out of range", global_argv[argnum]);
+ error (0, 0, _("%s: line number out of range"), global_argv[argnum]);
cleanup ();
}
if (!ignore)
struct control *p;
int repetition;
{
- fprintf (stderr, "%s: `%d': line number out of range",
+ fprintf (stderr, _("%s: `%d': line number out of range"),
program_name, p->lines_required);
if (repetition)
- fprintf (stderr, " on repetition %d\n", repetition);
+ fprintf (stderr, _(" on repetition %d\n"), repetition);
else
fprintf (stderr, "\n");
int repetition;
boolean ignore;
{
- fprintf (stderr, "%s: `%s': match not found",
+ fprintf (stderr, _("%s: `%s': match not found"),
program_name, global_argv[p->argnum]);
if (repetition)
- fprintf (stderr, " on repetition %d\n", repetition);
+ fprintf (stderr, _(" on repetition %d\n"), repetition);
else
fprintf (stderr, "\n");
0, line_len, (struct re_registers *) 0);
if (ret == -2)
{
- error (0, 0, "error in regular expression search");
+ error (0, 0, _("error in regular expression search"));
cleanup ();
}
if (ret == -1)
0, line_len, (struct re_registers *) 0);
if (ret == -2)
{
- error (0, 0, "error in regular expression search");
+ error (0, 0, _("error in regular expression search"));
cleanup ();
}
if (ret >= 0)
{
if (fclose (output_stream) == EOF)
{
- error (0, errno, "write error for `%s'", output_filename);
+ error (0, errno, _("write error for `%s'"), output_filename);
cleanup ();
}
if (bytes_written == 0 && elide_empty_files)
char *num;
{
if (*num != '-' && *num != '+')
- error (1, 0, "%s: `+' or `-' expected after delimeter", str);
+ error (1, 0, _("%s: `+' or `-' expected after delimeter"), str);
if (!string_to_number (&p->offset, num + 1))
- error (1, 0, "%s: integer expected after `%c'", str, *num);
+ error (1, 0, _("%s: integer expected after `%c'"), str, *num);
if (*num == '-')
p->offset = -p->offset;
end = str + strlen (str) - 1;
if (*end != '}')
- error (1, 0, "%s: `}' is required in repeat count", str);
+ error (1, 0, _("%s: `}' is required in repeat count"), str);
*end = '\0';
if (str+1 == end-1 && *(str+1) == '*')
p->repeat_forever = 1;
else
if (!string_to_number (&p->repeat, str + 1))
- error (1, 0, "%s}: integer required between `{' and `}'",
+ error (1, 0, _("%s}: integer required between `{' and `}'"),
global_argv[argnum]);
*end = '}';
closing_delim = strrchr (str + 1, delim);
if (closing_delim == NULL)
- error (1, 0, "%s: closing delimeter `%c' missing", str, delim);
+ error (1, 0, _("%s: closing delimeter `%c' missing"), str, delim);
len = closing_delim - str - 1;
p = new_control_record ();
err = re_compile_pattern (p->regexpr, len, &p->re_compiled);
if (err)
{
- error (0, 0, "%s: invalid regular expression: %s", str, err);
+ error (0, 0, _("%s: invalid regular expression: %s"), str, err);
cleanup ();
}
p = new_control_record ();
p->argnum = i;
if (!string_to_number (&p->lines_required, argv[i]))
- error (1, 0, "%s: invalid pattern", argv[i]);
+ error (1, 0, _("%s: invalid pattern"), argv[i]);
}
if (i + 1 < argc && *argv[i + 1] == '{')
break;
case 0:
- error (1, 0, "missing conversion specifier in suffix");
+ error (1, 0, _("missing conversion specifier in suffix"));
break;
default:
if (ISPRINT (ch))
- error (1, 0, "invalid conversion specifier in suffix: %c", ch);
+ error (1, 0, _("invalid conversion specifier in suffix: %c"), ch);
else
- error (1, 0, "invalid conversion specifier in suffix: \\%.3o", ch);
+ error (1, 0, _("invalid conversion specifier in suffix: \\%.3o"), ch);
}
}
}
if (percents == 0)
- error (1, 0, "missing %% conversion specification in suffix");
+ error (1, 0, _("missing %% conversion specification in suffix"));
else if (percents > 1)
- error (1, 0, "too many %% conversion specifications in suffix");
+ error (1, 0, _("too many %% conversion specifications in suffix"));
return out_count;
}
interrupt_handler (signum)
int signum;
{
- error (0, 0, "interrupted");
+ error (0, 0, _("interrupted"));
cleanup ();
}
case 'n':
if (!string_to_number (&digits, optarg))
- error (1, 0, "%s: invalid number", optarg);
+ error (1, 0, _("%s: invalid number"), optarg);
break;
case 's':
if (argc - optind < 2)
{
- error (0, 0, "too few arguments");
+ error (0, 0, _("too few arguments"));
usage (1);
}
if (close (input_desc) < 0)
{
- error (0, errno, "read error");
+ error (0, errno, _("read error"));
cleanup ();
}
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... FILE PATTERN...\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Output pieces of FILE separated by PATTERN(s) to files `xx01', `xx02', ...,\n\
and output byte counts of each piece to standard output.\n\
\n\
{*} repeat the previous pattern as many times as possible\n\
\n\
A line OFFSET is a required `+' or `-' followed by a positive integer.\n\
-");
+"));
}
exit (status);
}
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... [FILE]...\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Print selected parts of lines from each FILE to standard output.\n\
\n\
-b, --bytes=LIST output only these bytes\n\
-M from first to M'th (included) byte, character or field\n\
\n\
With no FILE, or when FILE is -, read standard input.\n\
-");
+"));
}
exit (status);
}
{
/* Starting a range. */
if (dash_found)
- FATAL_ERROR ("invalid byte or field list");
+ FATAL_ERROR (_("invalid byte or field list"));
dash_found++;
fieldstr++;
{
/* `m-n' or `-n' (1-n). */
if (value < initial)
- FATAL_ERROR ("invalid byte or field list");
+ FATAL_ERROR (_("invalid byte or field list"));
/* Is there already a range going to end of line? */
if (eol_range_start != 0)
fieldstr++;
}
else
- FATAL_ERROR ("invalid byte or field list");
+ FATAL_ERROR (_("invalid byte or field list"));
}
max_range_endpoint = 0;
case 'c':
/* Build the byte list. */
if (operating_mode != undefined_mode)
- FATAL_ERROR ("only one type of list may be specified");
+ FATAL_ERROR (_("only one type of list may be specified"));
operating_mode = byte_mode;
if (set_fields (optarg) == 0)
- FATAL_ERROR ("missing list of positions");
+ FATAL_ERROR (_("missing list of positions"));
break;
case 'f':
/* Build the field list. */
if (operating_mode != undefined_mode)
- FATAL_ERROR ("only one type of list may be specified");
+ FATAL_ERROR (_("only one type of list may be specified"));
operating_mode = field_mode;
if (set_fields (optarg) == 0)
- FATAL_ERROR ("missing list of fields");
+ FATAL_ERROR (_("missing list of fields"));
break;
case 'd':
/* New delimiter. */
/* Interpret -d '' to mean `use the NUL byte as the delimiter.' */
if (optarg[0] != '\0' && optarg[1] != '\0')
- FATAL_ERROR ("the delimiter must be a single character");
+ FATAL_ERROR (_("the delimiter must be a single character"));
delim = optarg[0];
break;
usage (0);
if (operating_mode == undefined_mode)
- FATAL_ERROR ("you must specify a list of bytes, characters, or fields");
+ FATAL_ERROR (_("you must specify a list of bytes, characters, or fields"));
if (delim != '\0' && operating_mode != field_mode)
- FATAL_ERROR ("a delimiter may be specified only when operating on fields");
+ FATAL_ERROR (_("a delimiter may be specified only when operating on fields"));
if (suppress_non_delimited && operating_mode != field_mode)
- FATAL_ERROR ("suppressing non-delimited lines makes sense\n\
-\tonly when operating on fields");
+ FATAL_ERROR (_("suppressing non-delimited lines makes sense\n\
+\tonly when operating on fields"));
if (delim == '\0')
delim = '\t';
exit_status = 1;
}
if (ferror (stdout) || fclose (stdout) == EOF)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
exit (exit_status);
}
if (have_read_stdin && fclose (stdin) == EOF)
error (1, errno, "-");
if (ferror (stdout) || fclose (stdout) == EOF)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
exit (exit_status);
}
tabval = tabval * 10 + *stops - '0';
}
else
- error (1, 0, "tab size contains an invalid character");
+ error (1, 0, _("tab size contains an invalid character"));
}
add_tabstop (tabval);
for (i = 0; i < entries; i++)
{
if (tabs[i] == 0)
- error (1, 0, "tab size cannot be 0");
+ error (1, 0, _("tab size cannot be 0"));
if (tabs[i] <= prev_tab)
- error (1, 0, "tab sizes must be ascending");
+ error (1, 0, _("tab sizes must be ascending"));
prev_tab = tabs[i];
}
}
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... [FILE]...\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Convert tabs in each FILE to spaces, writing to standard output.\n\
With no FILE, or when FILE is -, read standard input.\n\
\n\
--version output version information and exit\n\
\n\
Instead of -t NUMBER or -t LIST, -NUMBER or -LIST may be used.\n\
-");
+"));
}
exit (status);
}
/* Forward declarations. */
-/* My AC_PROTOTYPES would be better than __STDC__. FIXME :-). */
-#if __STDC__
-#define _(x) x
-#else
-#define _(x) ()
+/* My fp_PROTOTYPES would be better than __STDC__. FIXME :-). */
+#ifndef __P
+# if __STDC__
+# define __P(Args) Args
+# else
+# define __P(Args) ()
+# endif
#endif
-static void set_prefix _ ((char *p));
-static void fmt _ ((FILE *f));
-static bool get_paragraph _ ((FILE *f));
-static int get_line _ ((FILE *f, int c));
-static int get_prefix _ ((FILE *f));
-static int get_space _ ((FILE *f, int c));
-static int copy_rest _ ((FILE *f, int c));
-static bool same_para _ ((int c));
-static void flush_paragraph _ ((void));
-static void fmt_paragraph _ ((void));
-static void check_punctuation _ ((WORD *w));
-static COST base_cost _ ((WORD *this));
-static COST line_cost _ ((WORD *next, int len));
-static void put_paragraph _ ((WORD *finish));
-static void put_line _ ((WORD *w, int indent));
-static void put_word _ ((WORD *w));
-static void put_space _ ((int space));
+static void set_prefix __P ((char *p));
+static void fmt __P ((FILE *f));
+static bool get_paragraph __P ((FILE *f));
+static int get_line __P ((FILE *f, int c));
+static int get_prefix __P ((FILE *f));
+static int get_space __P ((FILE *f, int c));
+static int copy_rest __P ((FILE *f, int c));
+static bool same_para __P ((int c));
+static void flush_paragraph __P ((void));
+static void fmt_paragraph __P ((void));
+static void check_punctuation __P ((WORD *w));
+static COST base_cost __P ((WORD *this));
+static COST line_cost __P ((WORD *next, int len));
+static void put_paragraph __P ((WORD *finish));
+static void put_line __P ((WORD *w, int indent));
+static void put_word __P ((WORD *w));
+static void put_space __P ((int space));
/* The name this program was run with. */
const char *program_name;
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n", program_name);
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
+ program_name);
else
{
- printf ("Usage: %s [-DIGITS] [OPTION]... [FILE]...\n", program_name);
- fputs ("\
+ printf (_("Usage: %s [-DIGITS] [OPTION]... [FILE]...\n"), program_name);
+ fputs (_("\
Reformat each paragraph in the FILE(s), writing to standard output.\n\
If no FILE or if FILE is `-', read standard input.\n\
\n\
--help display this help and exit\n\
--version output version information and exit\n\
\n\
-In -wNUMBER, the letter `w' may be omitted.\n",
+In -wNUMBER, the letter `w' may be omitted.\n"),
stdout);
}
exit (status);
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... [FILE]...\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Wrap input lines in each FILE (standard input by default), writing to\n\
standard output.\n\
\n\
-b, --bytes count bytes rather than columns\n\
-s, --spaces break at word boundaries\n\
-w, --width=WIDTH use WIDTH columns instead of 80\n\
-");
+"));
}
exit (status);
}
case 'w': /* Line width. */
width = atoi (optarg);
if (width < 1)
- error (1, 0, "%s: invalid line width", optarg);
+ error (1, 0, _("%s: invalid line width"), optarg);
break;
default:
if (have_read_stdin && fclose (stdin) == EOF)
error (1, errno, "-");
if (fclose (stdout) == EOF)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
exit (errs);
}
if (ferror (stdout))
{
- error (0, errno, "write error");
+ error (0, errno, _("write error"));
return 1;
}
break;
default:
- error (0, 0, "unrecognized option `-%c'", *argv[1]);
+ error (0, 0, _("unrecognized option `-%c'"), *argv[1]);
usage (1);
}
++argv[1];
getnum:
number = atou (optarg);
if (number == -1)
- error (1, 0, "invalid number `%s'", optarg);
+ error (1, 0, _("invalid number `%s'"), optarg);
break;
case 'q':
if (have_read_stdin && close (0) < 0)
error (1, errno, "-");
if (fclose (stdout) == EOF)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
exit (exit_status);
}
if (!strcmp (filename, "-"))
{
have_read_stdin = 1;
- filename = "standard input";
+ filename = _("standard input");
if (print_headers)
write_header (filename);
return head (filename, 0, number);
if (bytes_read > bytes_to_write)
bytes_read = bytes_to_write;
if (fwrite (buffer, 1, bytes_read, stdout) == 0)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
bytes_to_write -= bytes_read;
}
return 0;
if (buffer[bytes_to_write++] == '\n' && --lines_to_write == 0)
break;
if (fwrite (buffer, 1, bytes_to_write, stdout) == 0)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
}
return 0;
}
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... [FILE]...\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Print first 10 lines of each FILE to standard output.\n\
With more than one FILE, precede each with a header giving the file name.\n\
With no FILE, or when FILE is -, read standard input.\n\
SIZE may have a multiplier suffix: b for 512, k for 1K, m for 1 Meg.\n\
If -VALUE is used as first OPTION, read -c VALUE when one of\n\
multipliers bkm follows concatenated, else read -n VALUE.\n\
-");
+"));
}
exit (status);
}
else if (val == 2)
print_unpairables_2 = 1;
else
- error (2, 0, "invalid file number for `-a'");
+ error (2, 0, _("invalid file number for `-a'"));
break;
case 'e':
case '1':
val = atoi (optarg);
if (val <= 0)
- error (2, 0, "invalid field number for `-1'");
+ error (2, 0, _("invalid field number for `-1'"));
join_field_1 = val - 1;
break;
case '2':
val = atoi (optarg);
if (val <= 0)
- error (2, 0, "invalid field number for `-2'");
+ error (2, 0, _("invalid field number for `-2'"));
join_field_2 = val - 1;
break;
case 'j':
val = atoi (optarg);
if (val <= 0)
- error (2, 0, "invalid field number for `-j'");
+ error (2, 0, _("invalid field number for `-j'"));
join_field_1 = join_field_2 = val - 1;
break;
case 'o':
if (add_field_list (optarg) == 0)
- error (2, 0, "invalid field list for `-o'");
+ error (2, 0, _("invalid field list for `-o'"));
break;
case 't':
else if (val == 2)
print_unpairables_2 = 1;
else
- error (2, 0, "invalid file number for `-v'");
+ error (2, 0, _("invalid file number for `-v'"));
print_pairables = 0;
break;
if (!fp2)
error (1, errno, "%s", names[1]);
if (fp1 == fp2)
- error (1, errno, "both files cannot be standard input");
+ error (1, errno, _("both files cannot be standard input"));
join (fp1, fp2);
if ((fp1 == stdin || fp2 == stdin) && fclose (stdin) == EOF)
error (1, errno, "-");
if (ferror (stdout) || fclose (stdout) == EOF)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
exit (0);
}
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... FILE1 FILE2\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
For each pair of input lines with identical join fields, write a line to\n\
standard output. The default join field is the first, delimited\n\
by whitespace. When FILE1 or FILE2 (not both) is -, read standard input.\n\
comma or blank separated specifications, each being `SIDE.FIELD'.\n\
Default FORMAT outputs the join field, the remaining fields from\n\
FILE1, the remaining fields from FILE2, all separated by CHAR.\n\
-");
+"));
}
exit (status);
}
# define TOLOWER(c) (ISUPPER (c) ? tolower (c) : (c))
#endif
-/* Hook for i18n. */
-#define _(str) str
-
/* Nonzero if any of the files read were the standard input. */
static int have_read_stdin;
if (strcmp (checkfile_name, "-") == 0)
{
have_read_stdin = 1;
- checkfile_name = "standard input";
+ checkfile_name = _("standard input");
checkfile_stream = stdin;
}
else
exit_status = 1;
}
if (ferror (stdout) || fclose (stdout) == EOF)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
exit (exit_status);
}
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... [FILE]...\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Write each FILE to standard output, with line numbers added.\n\
With no FILE, or when FILE is -, read standard input.\n\
\n\
rn right justified, no leading zeros\n\
rz right justified, leading zeros\n\
\n\
-");
+"));
}
exit (status);
}
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... [FILE]...\n\
or: %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
-",
+"),
program_name, program_name);
- printf ("\
+ printf (_("\
Write an unambiguous representation, octal bytes by default, of FILE\n\
to standard output. With no FILE, or when FILE is -, read standard input.\n\
\n\
-l same as -t d4, select decimal longs\n\
-o same as -t o2, select octal shorts\n\
-x same as -t x2, select hexadecimal shorts\n\
-");
- printf ("\
+"));
+ printf (_("\
\n\
For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
is the pseudo-address at first byte printed, incremented when dump is\n\
with b suffix, by 1024 with k and by 1048576 with m. -s without a\n\
number implies 3. -w without a number implies 32. By default, od\n\
uses -A o -t d2 -w 16.\n\
-");
+"));
}
exit (status);
}
if (STREQ (*file_list, "-"))
{
- input_filename = "standard input";
+ input_filename = _("standard input");
in_stream = stdin;
have_read_stdin = 1;
}
}
if (n_skip != 0)
- error (2, 0, "cannot skip past end of combined input");
+ error (2, 0, _("cannot skip past end of combined input"));
return err;
}
if (ferror (stdout))
{
- error (0, errno, "standard output");
+ error (0, errno, _("standard output"));
err = 1;
}
if (STREQ (*file_list, "-"))
{
- input_filename = "standard input";
+ input_filename = _("standard input");
in_stream = stdin;
have_read_stdin = 1;
}
if (STREQ (*file_list, "-"))
{
- input_filename = "standard input";
+ input_filename = _("standard input");
in_stream = stdin;
have_read_stdin = 1;
}
s_err = xstrtoul (s, NULL, radix, &tmp, "Bb");
if (s_err != LONGINT_OK)
{
- STRTOL_FAIL_WARN (s, "old-style offset", s_err);
+ STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
return -1;
}
offset = tmp;
break;
default:
error (2, 0,
- "invalid output address radix `%c'; it must be one character from [doxn]",
+ _("invalid output address radix `%c'; it must be one character from [doxn]"),
optarg[0]);
break;
}
s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
n_bytes_to_skip = tmp;
if (s_err != LONGINT_OK)
- STRTOL_FATAL_ERROR (optarg, "skip argument", s_err);
+ STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
break;
case 'N':
s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
max_bytes_to_format = tmp;
if (s_err != LONGINT_OK)
- STRTOL_FATAL_ERROR (optarg, "limit argument", s_err);
+ STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
if (tmp > OFF_T_MAX)
- error (2, 0, "specified number of bytes `%s' is larger than \
-the maximum\nrepresentable value of type off_t", optarg);
+ error (2, 0, _("specified number of bytes `%s' is larger than \
+the maximum\nrepresentable value of type off_t"), optarg);
break;
case 's':
{
s_err = xstrtoul (optarg, NULL, 0, &string_min, "bkm");
if (s_err != LONGINT_OK)
- STRTOL_FATAL_ERROR (optarg, "minimum string length", s_err);
+ STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
}
++flag_dump_strings;
break;
case 't':
if (decode_format_string (optarg))
- error (2, 0, "invalid type string `%s'", optarg);
+ error (2, 0, _("invalid type string `%s'"), optarg);
break;
case 'v':
{
s_err = xstrtoul (optarg, NULL, 10, &desired_width, NULL);
if (s_err != LONGINT_OK)
- STRTOL_FATAL_ERROR (optarg, "width specification", s_err);
+ STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
}
break;
usage (0);
if (flag_dump_strings && n_specs > 0)
- error (2, 0, "no type may be specified when dumping strings");
+ error (2, 0, _("no type may be specified when dumping strings"));
n_files = argc - optind;
else
{
error (0, 0,
- "invalid second operand in compatibility mode `%s'",
+ _("invalid second operand in compatibility mode `%s'"),
argv[optind + 1]);
usage (1);
}
else
{
error (0, 0,
- "in compatibility mode the last 2 arguments must be offsets");
+ _("in compatibility mode the last 2 arguments must be offsets"));
usage (1);
}
}
else
{
error (0, 0,
- "in compatibility mode there may be no more than 3 arguments");
+ _("in compatibility mode there may be no more than 3 arguments"));
usage (1);
}
bytes_per_block = desired_width;
else
{
- error (0, 0, "warning: invalid width %lu; using %d instead",
+ error (0, 0, _("warning: invalid width %lu; using %d instead"),
desired_width, l_c_m);
bytes_per_block = l_c_m;
}
#ifdef DEBUG
for (i = 0; i < n_specs; i++)
{
- printf ("%d: fmt=\"%s\" width=%d\n",
+ printf (_("%d: fmt=\"%s\" width=%d\n"),
i, spec[i].fmt_string, width_bytes[spec[i].size]);
}
#endif
cleanup:;
if (have_read_stdin && fclose (stdin) == EOF)
- error (2, errno, "standard input");
+ error (2, errno, _("standard input"));
if (fclose (stdout) == EOF)
- error (2, errno, "write error");
+ error (2, errno, _("write error"));
exit (err);
}
if (have_read_stdin && fclose (stdin) == EOF)
error (1, errno, "-");
if (ferror (stdout) || fclose (stdout) == EOF)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
exit (exit_status);
}
fileptr[files_open] = ENDLIST;
if (opened_stdin && have_read_stdin)
- error (1, 0, "standard input is closed");
+ error (1, 0, _("standard input is closed"));
/* Read a line from each file and output it to stdout separated by a
delimiter, until we go through the loop without successfully
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... [FILE]...\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Write lines consisting of the sequentially corresponding lines from\n\
each FILE, separated by TABs, to standard output.\n\
With no FILE, or when FILE is -, read standard input.\n\
--help display this help and exit\n\
--version output version information and exit\n\
\n\
-");
+"));
}
exit (status);
}
++s;
if (!ISDIGIT (*s))
{
- error (0, 0, "`+' requires a numeric argument");
+ error (0, 0, _("`+' requires a numeric argument"));
usage (2);
}
/* FIXME: use strtol */
column_separator = *s;
if (*++s)
{
- fprintf (stderr, "\
-%s: extra characters in the argument to the `-s' option: `%s'\n",
+ fprintf (stderr, _("\
+%s: extra characters in the argument to the `-s' option: `%s'\n"),
program_name, s);
usage (2);
}
if (parallel_files && explicit_columns)
error (1, 0,
- "Cannot specify number of columns when printing in parallel.");
+ _("Cannot specify number of columns when printing in parallel."));
if (parallel_files && print_across_flag)
error (1, 0,
- "Cannot specify both printing across and printing in parallel.");
+ _("Cannot specify both printing across and printing in parallel."));
for ( ; optind < argc; optind++)
{
cleanup ();
if (have_read_stdin && fclose (stdin) == EOF)
- error (1, errno, "standard input");
+ error (1, errno, _("standard input"));
if (ferror (stdout) || fclose (stdout) == EOF)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
if (failed_opens > 0)
exit(1);
exit (0);
*number = atoi (arg);
else
{
- fprintf (stderr, "\
-%s: extra characters in the argument to the `-%c' option: `%s'\n",
+ fprintf (stderr, _("\
+%s: extra characters in the argument to the `-%c' option: `%s'\n"),
program_name, switch_char, arg);
usage (2);
}
(columns - 1) * chars_per_gutter) / columns;
if (chars_per_column < 1)
- error (1, 0, "page width too narrow");
+ error (1, 0, _("page width too narrow"));
if (numbered_lines)
{
}
else
{
- p->name = "standard input";
+ p->name = _("standard input");
p->fp = stdin;
have_read_stdin = TRUE;
p->status = OPEN;
{
if (!strcmp (name, "-"))
{
- p->name = "standard input";
+ p->name = _("standard input");
p->fp = stdin;
have_read_stdin = 1;
}
free (header);
header = (char *) xmalloc (chars_per_header * sizeof (char));
- sprintf (header, "%s %s %s Page", &t[4], &t[20], middle);
+ sprintf (header, _("%s %s %s Page"), &t[4], &t[20], middle);
}
\f
/* Set things up for printing a page
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... [FILE]...\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Paginate or columnate FILE(s) for printing.\n\
\n\
+PAGE begin printing with page PAGE\n\
\n\
-t implied by -l N when N < 10. Without -s, columns are separated by\n\
spaces. With no FILE, or when FILE is -, read standard input.\n\
-");
+"));
}
exit (status);
}
p = malloc (n);
if (p == 0)
{
- error (0, 0, "virtual memory exhausted");
+ error (0, 0, _("virtual memory exhausted"));
cleanup ();
exit (2);
}
p = realloc (p, n);
if (p == 0)
{
- error (0, 0, "virtual memory exhausted");
+ error (0, 0, _("virtual memory exhausted"));
cleanup ();
exit (2);
}
{
if (fflush (fp) != 0)
{
- error (0, errno, "flushing file");
+ error (0, errno, _("flushing file"));
cleanup ();
exit (2);
}
{
if (fclose (fp) != 0)
{
- error (0, errno, "error closing file");
+ error (0, errno, _("error closing file"));
cleanup ();
exit (2);
}
{
if (fwrite (buf, size, nelem, fp) != nelem)
{
- error (0, errno, "write error");
+ error (0, errno, _("write error"));
cleanup ();
exit (2);
}
cc = fread (buf->buf + buf->used, 1, buf->alloc - buf->used, fp);
if (ferror (fp))
{
- error (0, errno, "read error");
+ error (0, errno, _("read error"));
cleanup ();
exit (2);
}
fp = xfopen (files[i], "r");
if (!checkfp (fp))
{
- fprintf (stderr, "%s: disorder on %s\n", program_name, files[i]);
+ fprintf (stderr, _("%s: disorder on %s\n"), program_name, files[i]);
++disorders;
}
}
badfieldspec (s)
char *s;
{
- error (2, 0, "invalid field specification `%s'", s);
+ error (2, 0, _("invalid field specification `%s'"), s);
}
/* Handle interrupts and hangups. */
else
{
if (i == argc - 1)
- error (2, 0, "option `-k' requires an argument");
+ error (2, 0, _("option `-k' requires an argument"));
else
s = argv[++i];
}
else
{
if (i == argc - 1)
- error (2, 0, "option `-o' requires an argument");
+ error (2, 0, _("option `-o' requires an argument"));
else
outfile = argv[++i];
}
goto outer;
}
else
- error (2, 0, "option `-t' requires an argument");
+ error (2, 0, _("option `-t' requires an argument"));
break;
case 'T':
if (s[1])
if (i < argc - 1)
temp_file_prefix = argv[++i];
else
- error (2, 0, "option `-T' requires an argument");
+ error (2, 0, _("option `-T' requires an argument"));
}
goto outer;
/* break; */
Solaris 2. */
goto outer;
default:
- fprintf (stderr, "%s: unrecognized option `-%c'\n",
+ fprintf (stderr, _("%s: unrecognized option `-%c'\n"),
argv[0], *s);
usage (2);
}
Solaris, Ultrix, and Irix. This premature fflush makes the output
reappear. --karl@cs.umb.edu */
if (fflush (ofp) < 0)
- error (1, errno, "%s: write error", outfile);
+ error (1, errno, _("%s: write error"), outfile);
if (have_read_stdin && fclose (stdin) == EOF)
error (1, errno, outfile);
if (ferror (stdout) || fclose (stdout) == EOF)
- error (1, errno, "%s: write error", outfile);
+ error (1, errno, _("%s: write error"), outfile);
exit (0);
}
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... [FILE]...\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Write sorted concatenation of all FILE(s) to standard output.\n\
\n\
+POS1 [-POS2] start a key at POS1, end it before POS2\n\
or more of Mbdfinr, this effectively disable global -Mbdfinr settings\n\
for that key. If no key given, use the entire line as key. With no\n\
FILE, or when FILE is -, read standard input.\n\
-"
+")
, DEFAULT_TMPDIR);
}
exit (status);
fprintf (stderr, "%s: %s\n", program_name, reason);
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION] [INPUT [PREFIX]]\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Output fixed-size pieces of INPUT to PREFIXaa, PREFIXab, ...; default\n\
PREFIX is `x'. With no INPUT, or when INPUT is -, read standard input.\n\
\n\
--version output version information and exit\n\
\n\
SIZE may have a multiplier suffix: b for 512, k for 1K, m for 1 Meg.\n\
-");
+"));
}
exit (status);
}
case 'b':
if (split_type != type_undef)
- usage (2, "cannot split in more than one way");
+ usage (2, _("cannot split in more than one way"));
split_type = type_bytes;
if (convint (optarg, &accum) == -1)
- usage (2, "invalid number of bytes");
+ usage (2, _("invalid number of bytes"));
break;
case 'l':
if (split_type != type_undef)
- usage (2, "cannot split in more than one way");
+ usage (2, _("cannot split in more than one way"));
split_type = type_lines;
if (!isdigits (optarg))
- usage (2, "invalid number of lines");
+ usage (2, _("invalid number of lines"));
accum = atoi (optarg);
break;
case 'C':
if (split_type != type_undef)
- usage (2, "cannot split in more than one way");
+ usage (2, _("cannot split in more than one way"));
split_type = type_byteslines;
if (convint (optarg, &accum) == -1)
- usage (2, "invalid number of bytes");
+ usage (2, _("invalid number of bytes"));
break;
case '0':
case '8':
case '9':
if (split_type != type_undef && split_type != type_digits)
- usage (2, "cannot split in more than one way");
+ usage (2, _("cannot split in more than one way"));
if (digits_optind != 0 && digits_optind != this_optind)
accum = 0; /* More than one number given; ignore other. */
digits_optind = this_optind;
}
if (accum < 1)
- usage (2, "invalid number");
+ usage (2, _("invalid number"));
num = accum;
/* Get out the filename arguments. */
outbase = argv[optind++];
if (optind < argc)
- usage (2, "too many arguments");
+ usage (2, _("too many arguments"));
/* Open the input file. */
if (!strcmp (infile, "-"))
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... [FILE]...\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Print checksum and block counts for each FILE.\n\
\n\
-r defeat -s, use BSD sum algorithm, use 1K blocks\n\
--version output version information and exit\n\
\n\
With no FILE, or when FILE is -, read standard input.\n\
-");
+"));
}
exit (status);
}
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... [FILE]...\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Write each FILE to standard output, last line first.\n\
With no FILE, or when FILE is -, read standard input.\n\
\n\
-s, --separator=STRING use STRING as the separator instead of newline\n\
--help display this help and exit\n\
--version output version information and exit\n\
-");
+"));
}
exit (status);
}
case 's':
separator = optarg;
if (*separator == 0)
- error (1, 0, "separator cannot be empty");
+ error (1, 0, _("separator cannot be empty"));
break;
default:
usage (1);
if (have_read_stdin && close (0) < 0)
error (1, errno, "-");
if (close (1) < 0)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
exit (errors);
}
error, either. */
if (fstat (0, &stats))
{
- error (0, errno, "standard input");
+ error (0, errno, _("standard input"));
return 1;
}
if (S_ISREG (stats.st_mode))
- return tac (0, "standard input");
+ return tac (0, _("standard input"));
#ifdef _POSIX_VERSION
newact.sa_handler = cleanup;
}
if (bytes_read == -1)
{
- error (0, errno, "read error");
+ error (0, errno, _("read error"));
cleanup ();
}
}
match_start = buffer - 1;
else if (ret == -2)
{
- error (0, 0, "error in regular expression search");
+ error (0, 0, _("error in regular expression search"));
cleanup ();
}
else
{
if (full_write (desc, buffer, size) < 0)
{
- error (0, errno, "write error");
+ error (0, errno, _("write error"));
cleanup ();
}
}
p = malloc (n);
if (p == 0)
{
- error (0, 0, "virtual memory exhausted");
+ error (0, 0, _("virtual memory exhausted"));
cleanup ();
}
return p;
p = realloc (p, n);
if (p == 0)
{
- error (0, 0, "virtual memory exhausted");
+ error (0, 0, _("virtual memory exhausted"));
cleanup ();
}
return p;
assert ((fd) == 1); \
assert ((n_bytes) >= 0); \
if (n_bytes > 0 && fwrite ((buffer), 1, (n_bytes), stdout) == 0) \
- error (1, errno, "write error"); \
+ error (1, errno, _("write error")); \
} \
while (0)
n_units = tmp_long;
if (s_err == LONGINT_OVERFLOW)
{
- STRTOL_FATAL_ERROR (argv[1], "argument", s_err);
+ STRTOL_FATAL_ERROR (argv[1], _("argument"), s_err);
}
/* Parse any appended option letters. */
while (*p)
break;
default:
- error (0, 0, "unrecognized option `-%c'", *p);
+ error (0, 0, _("unrecognized option `-%c'"), *p);
usage (1);
}
++p;
if (s_err != LONGINT_OK)
{
STRTOL_FATAL_ERROR (optarg, (c == 'n'
- ? "number of lines"
- : "number of bytes"), s_err);
+ ? _("number of lines")
+ : _("number of bytes")), s_err);
}
break;
if (have_read_stdin && close (0) < 0)
error (1, errno, "-");
if (fclose (stdout) == EOF)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
exit (exit_status);
}
if (!strcmp (filename, "-"))
{
have_read_stdin = 1;
- filename = "standard input";
+ filename = _("standard input");
if (print_headers)
write_header (filename, NULL);
errors = tail (filename, 0, n_units);
{
if (fstat (0, &stats) < 0)
{
- error (0, errno, "standard input");
+ error (0, errno, _("standard input"));
errors = 1;
}
else if (!S_ISREG (stats.st_mode))
{
error (0, 0,
- "standard input: cannot follow end of non-regular file");
+ _("standard input: cannot follow end of non-regular file"));
errors = 1;
}
if (errors)
}
else if (!S_ISREG (stats.st_mode))
{
- error (0, 0, "%s: cannot follow end of non-regular file",
+ error (0, 0, _("%s: cannot follow end of non-regular file"),
filename);
errors = 1;
}
if (stats.st_size < file_sizes[i])
{
- write_header (names[i], "file truncated");
+ write_header (names[i], _("file truncated"));
last = i;
lseek (file_descs[i], stats.st_size, SEEK_SET);
file_sizes[i] = stats.st_size;
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... [FILE]...\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Print last 10 lines of each FILE to standard output.\n\
With more than one FILE, precede each with a header giving the file name.\n\
With no FILE, or when FILE is -, read standard input.\n\
or +VALUE is treated like -n VALUE or -n +VALUE unless VALUE has one of\n\
the [bkm] suffix multipliers, in which case it is treated like -c VALUE\n\
or -c +VALUE.\n\
-");
+"));
}
exit (status);
}
usage (int status)
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... SET1 [SET2]\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Translate, squeeze, and/or delete characters from standard input,\n\
writing to standard output.\n\
\n\
-t, --truncate-set1 first truncate SET1 to length of SET2\n\
--help display this help and exit\n\
--version output version information and exit\n\
-");
- printf ("\
+"));
+ printf (_("\
\n\
SETs are specified as strings of characters. Most represent themselves.\n\
Interpreted sequences are:\n\
[:upper:] all upper case letters\n\
[:xdigit:] all hexadecimal digits\n\
[=CHAR=] all characters which are equivalent to CHAR\n\
-");
- printf ("\
+"));
+ printf (_("\
\n\
Translation occurs if -d is not given and both SET1 and SET2 appear.\n\
-t may be used only when translating. SET2 is extended to length of\n\
only be used in pairs to specify case conversion. -s uses SET1 if not\n\
translating nor deleting; else squeezing uses SET2 and occurs after\n\
translation or deletion.\n\
-");
+"));
}
exit (status);
}
isn't clear on this, but one person has said
that in his interpretation, POSIX says tr
can't even give a warning. */
- error (0, 0, "warning: the ambiguous octal escape \
-\\%c%c%c is being\n\tinterpreted as the 2-byte sequence \\0%c%c, `%c'",
+ error (0, 0, _("warning: the ambiguous octal escape \
+\\%c%c%c is being\n\tinterpreted as the 2-byte sequence \\0%c%c, `%c'"),
s[i], s[i + 1], s[i + 2],
s[i], s[i + 1], s[i + 2]);
}
}
break;
case '\0':
- error (0, 0, "invalid backslash escape at end of string");
+ error (0, 0, _("invalid backslash escape at end of string"));
return 1;
default:
- error (0, 0, "invalid backslash escape `\\%c'", s[i + 1]);
+ error (0, 0, _("invalid backslash escape `\\%c'"), s[i + 1]);
return 1;
}
++i;
char *tmp2 = make_printable_char (last);
error (0, 0,
- "range-endpoints of `%s-%s' are in reverse collating sequence order",
+ _("range-endpoints of `%s-%s' are in reverse collating sequence order"),
tmp1, tmp2);
free (tmp1);
free (tmp2);
{
char *tmp = make_printable_str (char_class_str, len);
- error (0, 0, "invalid character class `%s'", tmp);
+ error (0, 0, _("invalid character class `%s'"), tmp);
free (tmp);
return 1;
}
{
char *tmp = make_printable_str (equiv_class_str, len);
- error (0, 0, "%s: equivalence class operand must be a single character",
+ error (0, 0, _("%s: equivalence class operand must be a single character"),
tmp);
free (tmp);
return 1;
if (non_neg_strtol (digit_str, digit_str_len, repeat_count))
{
char *tmp = make_printable_str (digit_str, digit_str_len);
- error (0, 0, "invalid repeat count `%s' in [c*n] construct",
+ error (0, 0, _("invalid repeat count `%s' in [c*n] construct"),
tmp);
free (tmp);
return -2;
get_s1_spec_stats (s1);
if (s1->n_indefinite_repeats > 0)
{
- error (1, 0, "the [c*] repeat construct may not appear in string1");
+ error (1, 0, _("the [c*] repeat construct may not appear in string1"));
}
/* FIXME: it isn't clear from the POSIX spec that this is invalid,
if (complement && s1->has_upper_or_lower)
{
error (1, 0,
- "character classes may not be used when translating \
-and complementing");
+ _("character classes may not be used when translating \
+and complementing"));
}
if (s2)
if (s2->has_restricted_char_class)
{
error (1, 0,
- "when translating, the only character classes that may \
-appear in\n\tstring2 are `upper' and `lower'");
+ _("when translating, the only character classes that may \
+appear in\n\tstring2 are `upper' and `lower'"));
}
if (s2->n_indefinite_repeats > 1)
{
- error (1, 0, "only one [c*] repeat construct may appear in string2");
+ error (1, 0, _("only one [c*] repeat construct may appear in string2"));
}
if (translating)
if (s2->has_equiv_class)
{
error (1, 0,
- "[=c=] expressions may not appear in string2 \
-when translating");
+ _("[=c=] expressions may not appear in string2 \
+when translating"));
}
if (s1->length > s2->length)
if (s2->length == 0)
error (1, 0,
- "when not truncating set1, string2 must be non-empty");
+ _("when not truncating set1, string2 must be non-empty"));
string2_extend (s1, s2);
}
}
if (complement && s2->has_upper_or_lower)
error (1, 0,
- "character classes may not be used when translating \
-and complementing");
+ _("character classes may not be used when translating \
+and complementing"));
}
else
/* Not translating. */
{
if (s2->n_indefinite_repeats > 0)
error (1, 0,
- "the [c*] construct may appear in string2 only \
-when translating");
+ _("the [c*] construct may appear in string2 only \
+when translating"));
}
}
}
nr = (*reader) (buf, size, NULL);
if (nr < 0)
- error (1, errno, "read error");
+ error (1, errno, _("read error"));
if (nr == 0)
break;
i = 0;
}
if (out_len > 0
&& fwrite ((char *) &buf[begin], 1, out_len, stdout) == 0)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
}
if (char_to_squeeze != NOT_A_CHAR)
int nr = safe_read (0, (char *) buf, size);
if (nr < 0)
- error (1, errno, "read error");
+ error (1, errno, _("read error"));
if (nr == 0)
{
hit_eof = 1;
chars_read = safe_read (0, (char *) buf, size);
if (chars_read < 0)
- error (1, errno, "read error");
+ error (1, errno, _("read error"));
if (chars_read == 0)
{
hit_eof = 1;
of `cat' use `tr a a'. */
if (non_option_args > 2)
{
- error (0, 0, "too many arguments");
+ error (0, 0, _("too many arguments"));
usage (2);
}
if (!delete && !squeeze_repeats && non_option_args != 2)
- error (1, 0, "two strings must be given when translating");
+ error (1, 0, _("two strings must be given when translating"));
if (delete && squeeze_repeats && non_option_args != 2)
- error (1, 0, "two strings must be given when both \
-deleting and squeezing repeats");
+ error (1, 0, _("two strings must be given when both \
+deleting and squeezing repeats"));
/* If --delete is given without --squeeze-repeats, then
only one string argument may be specified. But POSIX
--non_option_args;
else
error (1, 0,
- "only one string may be given when deleting \
-without squeezing repeats");
+ _("only one string may be given when deleting \
+without squeezing repeats"));
}
if (squeeze_repeats && non_option_args == 0)
- error (1, 0, "at least one string must be given when squeezing repeats");
+ error (1, 0, _("at least one string must be given when squeezing repeats"));
spec_init (s1);
if (parse_str ((unsigned char *) argv[optind], s1))
{
nr = read_and_delete (io_buf, IO_BUF_SIZE, NULL);
if (nr > 0 && fwrite ((char *) io_buf, 1, nr, stdout) == 0)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
}
while (nr > 0);
}
c2 = get_next (s2, &class_s2);
if (!class_ok[(int) class_s1][(int) class_s2])
error (1, 0,
- "misaligned or mismatched upper and/or lower classes");
+ _("misaligned or mismatched upper and/or lower classes"));
/* The following should have been checked by validate... */
if (c2 == -1)
break;
chars_read = read_and_xlate (io_buf, IO_BUF_SIZE, NULL);
if (chars_read > 0
&& fwrite ((char *) io_buf, 1, chars_read, stdout) == 0)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
}
while (chars_read > 0);
}
}
if (fclose (stdout) == EOF)
- error (2, errno, "write error");
+ error (2, errno, _("write error"));
if (close (0) != 0)
- error (2, errno, "standard input");
+ error (2, errno, _("standard input"));
exit (0);
}
if (have_read_stdin && fclose (stdin) == EOF)
error (1, errno, "-");
if (fclose (stdout) == EOF)
- error (1, errno, "write error");
+ error (1, errno, _("write error"));
exit (exit_status);
}
tabval = tabval * 10 + *stops - '0';
}
else
- error (1, 0, "tab size contains an invalid character");
+ error (1, 0, _("tab size contains an invalid character"));
}
add_tabstop (tabval);
for (i = 0; i < entries; i++)
{
if (tabs[i] == 0)
- error (1, 0, "tab size cannot be 0");
+ error (1, 0, _("tab size cannot be 0"));
if (tabs[i] <= prev_tab)
- error (1, 0, "tab sizes must be ascending");
+ error (1, 0, _("tab sizes must be ascending"));
prev_tab = tabs[i];
}
}
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... [FILE]...\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Convert spaces in each FILE to tabs, writing to standard output.\n\
With no FILE, or when FILE is -, read standard input.\n\
\n\
--version output version information and exit\n\
\n\
Instead of -t NUMBER or -t LIST, -NUMBER or -LIST may be used.\n\
-");
+"));
}
exit (status);
}
closefiles:
if (ferror (istream) || fclose (istream) == EOF)
- error (1, errno, "error reading %s", infile);
+ error (1, errno, _("error reading %s"), infile);
if (ferror (ostream) || fclose (ostream) == EOF)
- error (1, errno, "error writing %s", outfile);
+ error (1, errno, _("error writing %s"), outfile);
free (lb1.buffer);
free (lb2.buffer);
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... [INPUT [OUTPUT]]\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Discard all but one of successive identical lines from INPUT (or\n\
standard input), writing to OUTPUT (or standard output).\n\
\n\
\n\
A field is a run of whitespace, than non-whitespace characters.\n\
Fields are skipped before chars. \n\
-");
+"));
}
exit (status);
}
int status;
{
if (status != 0)
- fprintf (stderr, "Try `%s --help' for more information.\n",
+ fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
- printf ("\
+ printf (_("\
Usage: %s [OPTION]... [FILE]...\n\
-",
+"),
program_name);
- printf ("\
+ printf (_("\
Print line, word, and byte counts for each FILE, and a total line if\n\
more than one FILE is specified. With no FILE, or when FILE is -,\n\
read standard input.\n\
-c, --bytes, --chars print the byte counts\n\
--help display this help and exit\n\
--version output version information and exit\n\
-");
+"));
}
exit (status);
}
wc_file (argv[optind]);
if (nfiles > 1)
- write_counts (total_lines, total_words, total_chars, "total");
+ write_counts (total_lines, total_words, total_chars, _("total"));
}
if (have_read_stdin && close (0))
projects / thirdparty / coreutils.git / commitdiff
