]>
Commit | Line | Data |
---|---|---|
6fd30452 AM |
1 | diff -ur coreutils-7.6.org/po/pl.po coreutils-7.6/po/pl.po |
2 | --- coreutils-7.6.org/po/pl.po 2009-09-12 20:25:34.788233704 +0200 | |
3 | +++ coreutils-7.6/po/pl.po 2009-09-12 20:25:11.898026716 +0200 | |
4 | @@ -4202,12 +4202,14 @@ | |
5 | #: src/fmt.c:285 | |
6 | msgid "" | |
7 | " -t, --tagged-paragraph indentation of first line different from second\n" | |
8 | -" -u, --uniform-spacing one space between words, two after sentences\n" | |
9 | +" -u, --uniform-spacing one space between words, two between sentences\n" | |
10 | +" -n, --single-spaces single spaces between sentences\n" | |
11 | " -w, --width=WIDTH maximum line width (default of 75 columns)\n" | |
12 | msgstr "" | |
13 | " -t, --tagged-paragraph wcięcie pierwszej linii inne niż drugiej\n" | |
14 | " -u, --uniform-spacing jedna spacja między słowami, dwie między " | |
15 | "zdaniami\n" | |
16 | +" -n, --single-spaces pojedyncze spacje między zdaniami\n" | |
17 | " -w, --width=ILE maksymalna szerokość linii (domyślnie 75 " | |
18 | "kolumn)\n" | |
19 | ||
20 | diff -ur coreutils-7.6.org/src/fmt.c coreutils-7.6/src/fmt.c | |
21 | --- coreutils-7.6.org/src/fmt.c 2009-09-01 13:01:16.000000000 +0200 | |
22 | +++ coreutils-7.6/src/fmt.c 2009-09-12 20:25:11.894693234 +0200 | |
23 | @@ -17,6 +17,7 @@ | |
29623d34 | 24 | /* Written by Ross Paterson <rap@doc.ic.ac.uk>. */ |
25 | ||
26 | #include <config.h> | |
27 | +#include <wchar.h> | |
28 | #include <stdio.h> | |
29 | #include <sys/types.h> | |
30 | #include <getopt.h> | |
6fd30452 | 31 | @@ -38,7 +39,7 @@ |
29623d34 | 32 | /* The following parameters represent the program's idea of what is |
33 | "best". Adjust to taste, subject to the caveats given. */ | |
34 | ||
35 | -/* Default longest permitted line length (max_width). */ | |
36 | +/* Default longest permitted line width (max_width). */ | |
37 | #define WIDTH 75 | |
38 | ||
39 | /* Prefer lines to be LEEWAY % shorter than the maximum width, giving | |
6fd30452 | 40 | @@ -50,7 +51,7 @@ |
29623d34 | 41 | #define DEF_INDENT 3 |
42 | ||
43 | /* Costs and bonuses are expressed as the equivalent departure from the | |
44 | - optimal line length, multiplied by 10. e.g. assigning something a | |
45 | + optimal line width, multiplied by 10. e.g. assigning something a | |
46 | cost of 50 means that it is as bad as a line 5 characters too short | |
47 | or too long. The definition of SHORT_COST(n) should not be changed. | |
48 | However, EQUIV(n) may need tuning. */ | |
6fd30452 | 49 | @@ -77,11 +78,11 @@ |
29623d34 | 50 | #define LINE_COST EQUIV (70) |
51 | ||
52 | /* Cost of breaking a line after the first word of a sentence, where | |
53 | - the length of the word is N. */ | |
54 | + the width of the word is N. */ | |
55 | #define WIDOW_COST(n) (EQUIV (200) / ((n) + 2)) | |
56 | ||
57 | /* Cost of breaking a line before the last word of a sentence, where | |
58 | - the length of the word is N. */ | |
59 | + the width of the word is N. */ | |
60 | #define ORPHAN_COST(n) (EQUIV (150) / ((n) + 2)) | |
61 | ||
62 | /* Bonus for breaking a line at the end of a sentence. */ | |
6fd30452 | 63 | @@ -113,11 +114,30 @@ |
29623d34 | 64 | #define MAXWORDS 1000 |
65 | #define MAXCHARS 5000 | |
66 | ||
67 | +/* Wide character support */ | |
68 | + | |
69 | +static wint_t | |
70 | +xgetwc (FILE *stream) | |
71 | +{ | |
72 | + wint_t c = getwc (stream); | |
73 | + if (c == WEOF && ferror (stream)) | |
74 | + error (EXIT_FAILURE, errno, _("read error")); | |
75 | + return c; | |
76 | +} | |
77 | + | |
78 | +static inline int | |
79 | +xwcwidth (wchar_t wc) | |
80 | +{ | |
81 | + int w = wcwidth (wc); | |
82 | + return w < 0 ? 0 : w; | |
83 | +} | |
84 | + | |
85 | /* Extra ctype(3)-style macros. */ | |
86 | ||
87 | -#define isopen(c) (strchr ("([`'\"", c) != NULL) | |
88 | -#define isclose(c) (strchr (")]'\"", c) != NULL) | |
89 | -#define isperiod(c) (strchr (".?!", c) != NULL) | |
90 | +#define isopen(c) \ | |
91 | + (wcschr (L"([`'\"\u2018\u201A\u201B\u201C\u201E\u201F", c) != NULL) | |
92 | +#define isclose(c) (wcschr (L")]'\"\u2018\u2019\u201C\u201D", c) != NULL) | |
93 | +#define isperiod(c) (wcschr (L".?!", c) != NULL) | |
94 | ||
95 | /* Size of a tab stop, for expansion on input and re-introduction on | |
96 | output. */ | |
6fd30452 | 97 | @@ -132,8 +152,9 @@ |
29623d34 | 98 | |
99 | /* Static attributes determined during input. */ | |
100 | ||
101 | - const char *text; /* the text of the word */ | |
102 | - int length; /* length of this word */ | |
103 | + const wchar_t *text; /* the text of the word */ | |
104 | + int length; /* length of this word, in characters */ | |
105 | + int width; /* width of this word, in columns */ | |
106 | int space; /* the size of the following space */ | |
107 | unsigned int paren:1; /* starts with open paren */ | |
108 | unsigned int period:1; /* ends in [.?!])* */ | |
6fd30452 | 109 | @@ -142,7 +163,7 @@ |
29623d34 | 110 | |
111 | /* The remaining fields are computed during the optimization. */ | |
112 | ||
113 | - int line_length; /* length of the best line starting here */ | |
114 | + int line_width; /* width of the best line starting here */ | |
115 | COST best_cost; /* cost of best paragraph starting here */ | |
116 | WORD *next_break; /* break which achieves best_cost */ | |
117 | }; | |
6fd30452 | 118 | @@ -152,16 +173,16 @@ |
29623d34 | 119 | static void set_prefix (char *p); |
120 | static void fmt (FILE *f); | |
121 | static bool get_paragraph (FILE *f); | |
122 | -static int get_line (FILE *f, int c); | |
123 | -static int get_prefix (FILE *f); | |
124 | -static int get_space (FILE *f, int c); | |
125 | -static int copy_rest (FILE *f, int c); | |
126 | -static bool same_para (int c); | |
127 | +static wint_t get_line (FILE *f, wint_t c); | |
128 | +static wint_t get_prefix (FILE *f); | |
129 | +static wint_t get_space (FILE *f, wint_t c); | |
130 | +static wint_t copy_rest (FILE *f, wint_t c); | |
131 | +static bool same_para (wint_t c); | |
132 | static void flush_paragraph (void); | |
133 | static void fmt_paragraph (void); | |
134 | static void check_punctuation (WORD *w); | |
135 | static COST base_cost (WORD *this); | |
136 | -static COST line_cost (WORD *next, int len); | |
137 | +static COST line_cost (WORD *next, int wid); | |
138 | static void put_paragraph (WORD *finish); | |
139 | static void put_line (WORD *w, int indent); | |
140 | static void put_word (WORD *w); | |
6fd30452 | 141 | @@ -181,8 +202,11 @@ |
29623d34 | 142 | /* If true, don't preserve inter-word spacing (default false). */ |
143 | static bool uniform; | |
144 | ||
145 | +/* How many spaces to put after a sentence (1 or 2). */ | |
146 | +static int sentence_space; | |
147 | + | |
148 | /* Prefix minus leading and trailing spaces (default ""). */ | |
149 | -static const char *prefix; | |
150 | +static wchar_t *prefix; | |
151 | ||
152 | /* User-supplied maximum line width (default WIDTH). The only output | |
153 | lines longer than this will each comprise a single word. */ | |
6fd30452 | 154 | @@ -190,14 +214,14 @@ |
29623d34 | 155 | |
156 | /* Values derived from the option values. */ | |
157 | ||
158 | -/* The length of prefix minus leading space. */ | |
159 | -static int prefix_full_length; | |
160 | +/* The width of prefix minus leading space. */ | |
161 | +static int prefix_full_width; | |
162 | ||
163 | -/* The length of the leading space trimmed from the prefix. */ | |
164 | +/* The width of the leading space trimmed from the prefix. */ | |
165 | static int prefix_lead_space; | |
166 | ||
167 | -/* The length of prefix minus leading and trailing space. */ | |
168 | -static int prefix_length; | |
169 | +/* The width of prefix minus leading and trailing space. */ | |
170 | +static int prefix_width; | |
171 | ||
172 | /* The preferred width of text lines, set to LEEWAY % less than max_width. */ | |
173 | static int best_width; | |
6fd30452 | 174 | @@ -212,10 +236,10 @@ |
29623d34 | 175 | |
176 | /* Space for the paragraph text -- longer paragraphs are handled neatly | |
177 | (cf. flush_paragraph()). */ | |
178 | -static char parabuf[MAXCHARS]; | |
179 | +static wchar_t parabuf[MAXCHARS]; | |
180 | ||
181 | /* A pointer into parabuf, indicating the first unused character position. */ | |
182 | -static char *wptr; | |
183 | +static wchar_t *wptr; | |
184 | ||
185 | /* The words of a paragraph -- longer paragraphs are handled neatly | |
186 | (cf. flush_paragraph()). */ | |
6fd30452 | 187 | @@ -247,16 +271,16 @@ |
29623d34 | 188 | prefix (next_prefix_indent). See get_paragraph() and copy_rest(). */ |
189 | ||
190 | /* The last character read from the input file. */ | |
191 | -static int next_char; | |
192 | +static wint_t next_char; | |
193 | ||
194 | /* The space before the trimmed prefix (or part of it) on the next line | |
195 | after the current paragraph. */ | |
196 | static int next_prefix_indent; | |
197 | ||
198 | -/* If nonzero, the length of the last line output in the current | |
199 | +/* If nonzero, the width of the last line output in the current | |
200 | paragraph, used to charge for raggedness at the split point for long | |
201 | paragraphs chosen by fmt_paragraph(). */ | |
202 | -static int last_line_length; | |
203 | +static int last_line_width; | |
204 | ||
205 | void | |
206 | usage (int status) | |
6fd30452 AM |
207 | @@ -284,7 +308,8 @@ |
208 | stdout); | |
29623d34 | 209 | fputs (_("\ |
210 | -t, --tagged-paragraph indentation of first line different from second\n\ | |
eb0f91a0 | 211 | - -u, --uniform-spacing one space between words, two after sentences\n\ |
212 | + -u, --uniform-spacing one space between words, two between sentences\n\ | |
213 | + -n, --single-spaces single spaces between sentences\n\ | |
29623d34 | 214 | -w, --width=WIDTH maximum line width (default of 75 columns)\n\ |
215 | "), stdout); | |
216 | fputs (HELP_OPTION_DESCRIPTION, stdout); | |
6fd30452 | 217 | @@ -307,6 +332,7 @@ |
29623d34 | 218 | {"split-only", no_argument, NULL, 's'}, |
219 | {"tagged-paragraph", no_argument, NULL, 't'}, | |
220 | {"uniform-spacing", no_argument, NULL, 'u'}, | |
eb0f91a0 | 221 | + {"single-spaces", no_argument, NULL, 'n'}, |
29623d34 | 222 | {"width", required_argument, NULL, 'w'}, |
223 | {GETOPT_HELP_OPTION_DECL}, | |
224 | {GETOPT_VERSION_OPTION_DECL}, | |
6fd30452 | 225 | @@ -329,9 +355,10 @@ |
eb0f91a0 | 226 | atexit (close_stdout); |
29623d34 | 227 | |
228 | crown = tagged = split = uniform = false; | |
eb0f91a0 | 229 | + sentence_space = 2; |
29623d34 | 230 | max_width = WIDTH; |
231 | - prefix = ""; | |
232 | - prefix_length = prefix_lead_space = prefix_full_length = 0; | |
233 | + prefix = L""; | |
234 | + prefix_width = prefix_lead_space = prefix_full_width = 0; | |
235 | ||
236 | if (argc > 1 && argv[1][0] == '-' && ISDIGIT (argv[1][1])) | |
237 | { | |
6fd30452 | 238 | @@ -344,7 +371,7 @@ |
29623d34 | 239 | argc--; |
240 | } | |
241 | ||
242 | - while ((optchar = getopt_long (argc, argv, "0123456789cstuw:p:", | |
243 | + while ((optchar = getopt_long (argc, argv, "0123456789cstunw:p:", | |
6fd30452 AM |
244 | long_options, NULL)) |
245 | != -1) | |
29623d34 | 246 | switch (optchar) |
6fd30452 AM |
247 | @@ -372,6 +399,10 @@ |
248 | uniform = true; | |
249 | break; | |
29623d34 | 250 | |
eb0f91a0 | 251 | + case 'n': |
252 | + sentence_space = 1; | |
6fd30452 | 253 | + break; |
eb0f91a0 | 254 | + |
29623d34 | 255 | case 'w': |
6fd30452 AM |
256 | max_width_option = optarg; |
257 | break; | |
258 | @@ -436,26 +467,32 @@ | |
29623d34 | 259 | } |
260 | ||
261 | /* Trim space from the front and back of the string P, yielding the prefix, | |
262 | - and record the lengths of the prefix and the space trimmed. */ | |
263 | + and record the widths of the prefix and the space trimmed. */ | |
264 | ||
265 | static void | |
266 | set_prefix (char *p) | |
267 | { | |
268 | - char *s; | |
269 | + size_t len; | |
270 | + wchar_t *s; | |
271 | ||
272 | prefix_lead_space = 0; | |
273 | - while (*p == ' ') | |
274 | + while (*p == L' ') | |
275 | { | |
276 | prefix_lead_space++; | |
277 | p++; | |
278 | } | |
279 | - prefix = p; | |
280 | - prefix_full_length = strlen (p); | |
281 | - s = p + prefix_full_length; | |
282 | - while (s > p && s[-1] == ' ') | |
283 | - s--; | |
284 | - *s = '\0'; | |
285 | - prefix_length = s - p; | |
286 | + len = mbsrtowcs (NULL, (const char **) &p, 0, NULL); | |
287 | + prefix = xmalloc (len * sizeof (wchar_t)); | |
288 | + mbsrtowcs (prefix, (const char **) &p, len, NULL); | |
289 | + for (s = prefix; *s; s++) | |
290 | + prefix_full_width += xwcwidth (*s); | |
291 | + prefix_width = prefix_full_width; | |
292 | + while (s > prefix && s[-1] == L' ') | |
293 | + { | |
294 | + s--; | |
295 | + prefix_width--; | |
296 | + } | |
297 | + *s = L'\0'; | |
298 | } | |
299 | ||
300 | /* read file F and send formatted output to stdout. */ | |
6fd30452 | 301 | @@ -524,24 +561,24 @@ |
29623d34 | 302 | static bool |
303 | get_paragraph (FILE *f) | |
304 | { | |
305 | - int c; | |
306 | + wint_t c; | |
307 | ||
308 | - last_line_length = 0; | |
309 | + last_line_width = 0; | |
310 | c = next_char; | |
311 | ||
312 | /* Scan (and copy) blank lines, and lines not introduced by the prefix. */ | |
313 | ||
314 | - while (c == '\n' || c == EOF | |
315 | + while (c == L'\n' || c == WEOF | |
6fd30452 AM |
316 | || next_prefix_indent < prefix_lead_space |
317 | - || in_column < next_prefix_indent + prefix_full_length) | |
318 | + || in_column < next_prefix_indent + prefix_full_width) | |
29623d34 | 319 | { |
320 | c = copy_rest (f, c); | |
321 | - if (c == EOF) | |
322 | + if (c == WEOF) | |
6fd30452 AM |
323 | { |
324 | - next_char = EOF; | |
325 | + next_char = WEOF; | |
326 | return false; | |
327 | } | |
29623d34 | 328 | - putchar ('\n'); |
329 | + putwchar (L'\n'); | |
330 | c = get_prefix (f); | |
331 | } | |
332 | ||
6fd30452 | 333 | @@ -597,26 +634,26 @@ |
29623d34 | 334 | that failed to match the prefix. In the latter, C is \n or EOF. |
335 | Return the character (\n or EOF) ending the line. */ | |
336 | ||
337 | -static int | |
338 | -copy_rest (FILE *f, int c) | |
339 | +static wint_t | |
340 | +copy_rest (FILE *f, wint_t c) | |
341 | { | |
342 | - const char *s; | |
343 | + const wchar_t *s; | |
344 | ||
345 | out_column = 0; | |
956567ad JR |
346 | - if (in_column > next_prefix_indent || (c != '\n' && c != EOF)) |
347 | + if (in_column > next_prefix_indent || (c != L'\n' && c != WEOF)) | |
29623d34 | 348 | { |
349 | put_space (next_prefix_indent); | |
350 | for (s = prefix; out_column != in_column && *s; out_column++) | |
6fd30452 | 351 | - putchar (*s++); |
956567ad | 352 | - if (c != EOF && c != '\n') |
6fd30452 | 353 | + putwchar (*s++); |
956567ad | 354 | + if (c != WEOF && c != L'\n') |
6fd30452 | 355 | put_space (in_column - out_column); |
956567ad | 356 | - if (c == EOF && in_column >= next_prefix_indent + prefix_length) |
6fd30452 | 357 | - putchar ('\n'); |
d8cce012 | 358 | + if (c == WEOF && in_column >= next_prefix_indent + prefix_width) |
6fd30452 | 359 | + putwchar (L'\n'); |
29623d34 | 360 | } |
361 | - while (c != '\n' && c != EOF) | |
362 | + while (c != L'\n' && c != WEOF) | |
363 | { | |
364 | - putchar (c); | |
365 | - c = getc (f); | |
366 | + putwchar (c); | |
367 | + c = xgetwc (f); | |
368 | } | |
369 | return c; | |
370 | } | |
6fd30452 | 371 | @@ -626,11 +663,11 @@ |
29623d34 | 372 | otherwise false. */ |
373 | ||
374 | static bool | |
375 | -same_para (int c) | |
376 | +same_para (wint_t c) | |
377 | { | |
378 | return (next_prefix_indent == prefix_indent | |
6fd30452 AM |
379 | - && in_column >= next_prefix_indent + prefix_full_length |
380 | - && c != '\n' && c != EOF); | |
381 | + && in_column >= next_prefix_indent + prefix_full_width | |
382 | + && c != L'\n' && c != WEOF); | |
29623d34 | 383 | } |
384 | ||
385 | /* Read a line from input file F, given first non-blank character C | |
6fd30452 | 386 | @@ -641,11 +678,11 @@ |
29623d34 | 387 | |
388 | Return the first non-blank character of the next line. */ | |
389 | ||
390 | -static int | |
391 | -get_line (FILE *f, int c) | |
392 | +static wint_t | |
393 | +get_line (FILE *f, wint_t c) | |
394 | { | |
395 | int start; | |
396 | - char *end_of_parabuf; | |
397 | + wchar_t *end_of_parabuf; | |
398 | WORD *end_of_word; | |
399 | ||
400 | end_of_parabuf = ¶buf[MAXCHARS]; | |
6fd30452 | 401 | @@ -657,6 +694,7 @@ |
29623d34 | 402 | /* Scan word. */ |
403 | ||
404 | word_limit->text = wptr; | |
405 | + word_limit->width = 0; | |
406 | do | |
6fd30452 AM |
407 | { |
408 | if (wptr == end_of_parabuf) | |
409 | @@ -665,10 +703,12 @@ | |
410 | flush_paragraph (); | |
411 | } | |
412 | *wptr++ = c; | |
413 | - c = getc (f); | |
29623d34 | 414 | + word_limit->width += xwcwidth (c); |
6fd30452 AM |
415 | + c = xgetwc (f); |
416 | } | |
29623d34 | 417 | - while (c != EOF && !isspace (c)); |
418 | - in_column += word_limit->length = wptr - word_limit->text; | |
419 | + while (c != WEOF && !isspace (c)); | |
420 | + word_limit->length = wptr - word_limit->text; | |
421 | + in_column += word_limit->width; | |
422 | check_punctuation (word_limit); | |
423 | ||
424 | /* Scan inter-word space. */ | |
6fd30452 | 425 | @@ -676,11 +716,11 @@ |
29623d34 | 426 | start = in_column; |
427 | c = get_space (f, c); | |
428 | word_limit->space = in_column - start; | |
429 | - word_limit->final = (c == EOF | |
430 | + word_limit->final = (c == WEOF | |
6fd30452 AM |
431 | || (word_limit->period |
432 | - && (c == '\n' || word_limit->space > 1))); | |
29623d34 | 433 | - if (c == '\n' || c == EOF || uniform) |
6fd30452 AM |
434 | - word_limit->space = word_limit->final ? 2 : 1; |
435 | + && (c == L'\n' || word_limit->space > 1))); | |
29623d34 | 436 | + if (c == L'\n' || c == WEOF || uniform) |
6fd30452 | 437 | + word_limit->space = word_limit->final ? sentence_space : 1; |
29623d34 | 438 | if (word_limit == end_of_word) |
6fd30452 AM |
439 | { |
440 | set_other_indent (true); | |
441 | @@ -688,34 +728,34 @@ | |
442 | } | |
29623d34 | 443 | word_limit++; |
29623d34 | 444 | } |
956567ad JR |
445 | - while (c != '\n' && c != EOF); |
446 | + while (c != L'\n' && c != WEOF); | |
29623d34 | 447 | return get_prefix (f); |
448 | } | |
449 | ||
450 | /* Read a prefix from input file F. Return either first non-matching | |
451 | character, or first non-blank character after the prefix. */ | |
452 | ||
453 | -static int | |
454 | +static wint_t | |
455 | get_prefix (FILE *f) | |
456 | { | |
457 | - int c; | |
458 | + wint_t c; | |
459 | ||
460 | in_column = 0; | |
461 | - c = get_space (f, getc (f)); | |
462 | - if (prefix_length == 0) | |
463 | + c = get_space (f, xgetwc (f)); | |
464 | + if (prefix_width == 0) | |
465 | next_prefix_indent = prefix_lead_space < in_column ? | |
466 | prefix_lead_space : in_column; | |
467 | else | |
468 | { | |
469 | - const char *p; | |
470 | + const wchar_t *p; | |
471 | next_prefix_indent = in_column; | |
472 | - for (p = prefix; *p != '\0'; p++) | |
473 | + for (p = prefix; *p != L'\0'; p++) | |
6fd30452 AM |
474 | { |
475 | - unsigned char pc = *p; | |
476 | + wchar_t pc = *p; | |
477 | if (c != pc) | |
478 | return c; | |
479 | in_column++; | |
480 | - c = getc (f); | |
481 | + c = xgetwc (f); | |
482 | } | |
29623d34 | 483 | c = get_space (f, c); |
484 | } | |
6fd30452 | 485 | @@ -725,21 +765,21 @@ |
29623d34 | 486 | /* Read blank characters from input file F, starting with C, and keeping |
487 | in_column up-to-date. Return first non-blank character. */ | |
488 | ||
489 | -static int | |
490 | -get_space (FILE *f, int c) | |
491 | +static wint_t | |
492 | +get_space (FILE *f, wint_t c) | |
493 | { | |
dca140ed | 494 | while (true) |
29623d34 | 495 | { |
496 | - if (c == ' ') | |
497 | + if (c == L' ') | |
6fd30452 | 498 | in_column++; |
29623d34 | 499 | - else if (c == '\t') |
500 | + else if (c == L'\t') | |
6fd30452 AM |
501 | { |
502 | tabs = true; | |
503 | in_column = (in_column / TABWIDTH + 1) * TABWIDTH; | |
504 | } | |
29623d34 | 505 | else |
6fd30452 | 506 | return c; |
29623d34 | 507 | - c = getc (f); |
508 | + c = xgetwc (f); | |
509 | } | |
510 | } | |
511 | ||
6fd30452 | 512 | @@ -748,9 +788,9 @@ |
29623d34 | 513 | static void |
514 | check_punctuation (WORD *w) | |
515 | { | |
516 | - char const *start = w->text; | |
517 | - char const *finish = start + (w->length - 1); | |
518 | - unsigned char fin = *finish; | |
519 | + wchar_t const *start = w->text; | |
520 | + wchar_t const *finish = start + (w->length - 1); | |
521 | + wchar_t fin = *finish; | |
522 | ||
523 | w->paren = isopen (*start); | |
524 | w->punct = !! ispunct (fin); | |
6fd30452 | 525 | @@ -774,7 +814,9 @@ |
29623d34 | 526 | |
527 | if (word_limit == word) | |
528 | { | |
529 | - fwrite (parabuf, sizeof *parabuf, wptr - parabuf, stdout); | |
530 | + wchar_t *outptr; | |
531 | + for (outptr = parabuf; outptr < wptr; outptr++) | |
532 | + putwchar (*outptr); | |
533 | wptr = parabuf; | |
534 | return; | |
535 | } | |
6fd30452 | 536 | @@ -806,7 +848,8 @@ |
29623d34 | 537 | /* Copy text of words down to start of parabuf -- we use memmove because |
538 | the source and target may overlap. */ | |
539 | ||
540 | - memmove (parabuf, split_point->text, wptr - split_point->text); | |
541 | + memmove (parabuf, split_point->text, | |
542 | + (wptr - split_point->text) * sizeof (wchar_t)); | |
543 | shift = split_point->text - parabuf; | |
544 | wptr -= shift; | |
545 | ||
6fd30452 | 546 | @@ -830,53 +873,53 @@ |
29623d34 | 547 | fmt_paragraph (void) |
548 | { | |
549 | WORD *start, *w; | |
550 | - int len; | |
551 | + int wid; | |
552 | COST wcost, best; | |
553 | - int saved_length; | |
554 | + int saved_width; | |
555 | ||
556 | word_limit->best_cost = 0; | |
557 | - saved_length = word_limit->length; | |
558 | - word_limit->length = max_width; /* sentinel */ | |
559 | + saved_width = word_limit->width; | |
560 | + word_limit->width = max_width; /* sentinel */ | |
561 | ||
562 | for (start = word_limit - 1; start >= word; start--) | |
563 | { | |
564 | best = MAXCOST; | |
565 | - len = start == word ? first_indent : other_indent; | |
566 | + wid = start == word ? first_indent : other_indent; | |
567 | ||
568 | /* At least one word, however long, in the line. */ | |
569 | ||
570 | w = start; | |
571 | - len += w->length; | |
572 | + wid += w->width; | |
573 | do | |
6fd30452 AM |
574 | { |
575 | w++; | |
29623d34 | 576 | |
6fd30452 | 577 | /* Consider breaking before w. */ |
29623d34 | 578 | |
6fd30452 AM |
579 | - wcost = line_cost (w, len) + w->best_cost; |
580 | - if (start == word && last_line_length > 0) | |
581 | - wcost += RAGGED_COST (len - last_line_length); | |
29623d34 | 582 | + wcost = line_cost (w, wid) + w->best_cost; |
583 | + if (start == word && last_line_width > 0) | |
584 | + wcost += RAGGED_COST (wid - last_line_width); | |
6fd30452 AM |
585 | if (wcost < best) |
586 | { | |
587 | best = wcost; | |
588 | start->next_break = w; | |
589 | - start->line_length = len; | |
29623d34 | 590 | + start->line_width = wid; |
6fd30452 | 591 | } |
29623d34 | 592 | |
6fd30452 AM |
593 | - /* This is a kludge to keep us from computing `len' as the |
594 | - sum of the sentinel length and some non-zero number. | |
595 | - Since the sentinel w->length may be INT_MAX, adding | |
29623d34 | 596 | + /* This is a kludge to keep us from computing `wid' as the |
597 | + sum of the sentinel width and some non-zero number. | |
598 | + Since the sentinel w->width may be INT_MAX, adding | |
6fd30452 AM |
599 | to that would give a negative result. */ |
600 | if (w == word_limit) | |
601 | break; | |
29623d34 | 602 | |
6fd30452 | 603 | - len += (w - 1)->space + w->length; /* w > start >= word */ |
29623d34 | 604 | + wid += (w - 1)->space + w->width; /* w > start >= word */ |
6fd30452 | 605 | } |
29623d34 | 606 | - while (len < max_width); |
607 | + while (wid < max_width); | |
608 | start->best_cost = best + base_cost (start); | |
609 | } | |
610 | ||
611 | - word_limit->length = saved_length; | |
612 | + word_limit->width = saved_width; | |
613 | } | |
614 | ||
615 | /* Return the constant component of the cost of breaking before the | |
6fd30452 | 616 | @@ -901,33 +944,33 @@ |
29623d34 | 617 | else if ((this - 1)->punct) |
6fd30452 | 618 | cost -= PUNCT_BONUS; |
29623d34 | 619 | else if (this > word + 1 && (this - 2)->final) |
6fd30452 | 620 | - cost += WIDOW_COST ((this - 1)->length); |
29623d34 | 621 | + cost += WIDOW_COST ((this - 1)->width); |
622 | } | |
623 | ||
624 | if (this->paren) | |
625 | cost -= PAREN_BONUS; | |
626 | else if (this->final) | |
627 | - cost += ORPHAN_COST (this->length); | |
628 | + cost += ORPHAN_COST (this->width); | |
629 | ||
630 | return cost; | |
631 | } | |
632 | ||
633 | /* Return the component of the cost of breaking before word NEXT that | |
634 | - depends on LEN, the length of the line beginning there. */ | |
635 | + depends on WID, the width of the line beginning there. */ | |
636 | ||
637 | static COST | |
638 | -line_cost (WORD *next, int len) | |
639 | +line_cost (WORD *next, int wid) | |
640 | { | |
641 | int n; | |
642 | COST cost; | |
643 | ||
644 | if (next == word_limit) | |
645 | return 0; | |
646 | - n = best_width - len; | |
647 | + n = best_width - wid; | |
648 | cost = SHORT_COST (n); | |
649 | if (next->next_break != word_limit) | |
650 | { | |
651 | - n = len - next->line_length; | |
652 | + n = wid - next->line_width; | |
653 | cost += RAGGED_COST (n); | |
654 | } | |
655 | return cost; | |
6fd30452 | 656 | @@ -956,8 +999,8 @@ |
29623d34 | 657 | |
658 | out_column = 0; | |
659 | put_space (prefix_indent); | |
660 | - fputs (prefix, stdout); | |
661 | - out_column += prefix_length; | |
662 | + fputws (prefix, stdout); | |
663 | + out_column += prefix_width; | |
664 | put_space (indent - out_column); | |
665 | ||
666 | endline = w->next_break - 1; | |
6fd30452 | 667 | @@ -967,8 +1010,8 @@ |
29623d34 | 668 | put_space (w->space); |
669 | } | |
670 | put_word (w); | |
671 | - last_line_length = out_column; | |
672 | - putchar ('\n'); | |
673 | + last_line_width = out_column; | |
674 | + putwchar (L'\n'); | |
675 | } | |
676 | ||
677 | /* Output to stdout the word W. */ | |
6fd30452 | 678 | @@ -976,13 +1019,13 @@ |
29623d34 | 679 | static void |
680 | put_word (WORD *w) | |
681 | { | |
682 | - const char *s; | |
683 | + const wchar_t *s; | |
684 | int n; | |
685 | ||
686 | s = w->text; | |
687 | for (n = w->length; n != 0; n--) | |
688 | - putchar (*s++); | |
689 | - out_column += w->length; | |
690 | + putwchar (*s++); | |
691 | + out_column += w->width; | |
692 | } | |
693 | ||
694 | /* Output to stdout SPACE spaces, or equivalent tabs. */ | |
6fd30452 | 695 | @@ -999,13 +1042,13 @@ |
29623d34 | 696 | if (out_column + 1 < tab_target) |
6fd30452 AM |
697 | while (out_column < tab_target) |
698 | { | |
699 | - putchar ('\t'); | |
29623d34 | 700 | + putwchar (L'\t'); |
6fd30452 AM |
701 | out_column = (out_column / TABWIDTH + 1) * TABWIDTH; |
702 | } | |
29623d34 | 703 | } |
704 | while (out_column < space_target) | |
705 | { | |
706 | - putchar (' '); | |
707 | + putwchar (L' '); | |
708 | out_column++; | |
709 | } | |
710 | } |