Par-1.53.0/0000700000175000037200000000000013633300176010404 5ustar amcengPar-1.53.0/buffer.c0000600000175000037200000001052013633241650012022 0ustar amceng/* buffer.c last touched in Par 1.53.0 last meaningful change in Par 1.50 Copyright 1993, 1996 Adam M. Costello This is ANSI C code (C89). additem(), copyitems(), and nextitem() rely on the fact that sizeof (char) is 1. See section A7.4.8 of The C Programming Language, Second Edition, by Kerninghan and Ritchie. */ #include "buffer.h" /* Makes sure we're consistent with the prototypes. */ #include "errmsg.h" #include #include #include #undef NULL #define NULL ((void *) 0) #ifdef DONTFREE #define free(ptr) #endif struct buffer { struct block *firstblk, /* The first block. */ *current, /* The last non-empty block, or */ /* firstblk if all are empty. */ *nextblk; /* The block containing the item to be */ /* returned by nextitem(), or NULL. */ int nextindex; /* Index of item in nextblock->items. */ size_t itemsize; /* The size of an item. */ }; typedef struct block { struct block *next; /* The next block, or NULL if none. */ void *items; /* Storage for the items in this block. */ int maxhere, /* Number of items that fit in *items. */ numprevious, /* Total of numhere for all previous blocks. */ numhere; /* The first numhere slots in *items are filled. */ } block; buffer *newbuffer(size_t itemsize, errmsg_t errmsg) { buffer *buf; block *blk; void *items; int maxhere; maxhere = 124 / itemsize; if (maxhere < 4) maxhere = 4; buf = malloc(sizeof (buffer)); blk = malloc(sizeof (block)); items = malloc(maxhere * itemsize); if (!buf || !blk || !items) { strcpy(errmsg,outofmem); goto nberror; } buf->itemsize = itemsize; buf->firstblk = buf->current = buf->nextblk = blk; buf->nextindex = 0; blk->next = NULL; blk->numprevious = blk->numhere = 0; blk->maxhere = maxhere; blk->items = items; *errmsg = '\0'; return buf; nberror: if (buf) free(buf); if (blk) free(blk); if (items) free(items); return NULL; } void freebuffer(buffer *buf) { block *blk, *tmp; blk = buf->firstblk; while (blk) { tmp = blk; blk = blk->next; if (tmp->items) free(tmp->items); free(tmp); } free(buf); } void clearbuffer(buffer *buf) { block *blk; for (blk = buf->firstblk; blk; blk = blk->next) blk->numhere = 0; buf->current = buf->firstblk; } void additem(buffer *buf, const void *item, errmsg_t errmsg) { block *blk, *new; void *items; int maxhere; size_t itemsize = buf->itemsize; blk = buf->current; if (blk->numhere == blk->maxhere) { new = blk->next; if (!new) { maxhere = 2 * blk->maxhere; new = malloc(sizeof (block)); items = malloc(maxhere * itemsize); if (!new || !items) { strcpy(errmsg,outofmem); goto aierror; } blk->next = new; new->next = NULL; new->maxhere = maxhere; new->numprevious = blk->numprevious + blk->numhere; new->numhere = 0; new->items = items; } blk = buf->current = new; } memcpy( ((char *) blk->items) + (blk->numhere * itemsize), item, itemsize ); ++blk->numhere; *errmsg = '\0'; return; aierror: if (new) free(new); if (items) free(items); } int numitems(buffer *buf) { block *blk = buf->current; return blk->numprevious + blk->numhere; } void *copyitems(buffer *buf, errmsg_t errmsg) { int n; void *r; block *blk, *b; size_t itemsize = buf->itemsize; b = buf->current; n = b->numprevious + b->numhere; if (!n) return NULL; r = malloc(n * itemsize); if (!r) { strcpy(errmsg,outofmem); return NULL; } b = b->next; for (blk = buf->firstblk; blk != b; blk = blk->next) memcpy( ((char *) r) + (blk->numprevious * itemsize), blk->items, blk->numhere * itemsize); *errmsg = '\0'; return r; } void rewindbuffer(buffer *buf) { buf->nextblk = buf->firstblk; buf->nextindex = 0; } void *nextitem(buffer *buf) { void *r; if (!buf->nextblk || buf->nextindex >= buf->nextblk->numhere) return NULL; r = ((char *) buf->nextblk->items) + (buf->nextindex * buf->itemsize); if (++buf->nextindex >= buf->nextblk->maxhere) { buf->nextblk = buf->nextblk->next; buf->nextindex = 0; } return r; } Par-1.53.0/par.10000600000175000037200000014100013633300176011246 0ustar amceng.\" par.1 .\" last touched in Par 1.53.0 .\" last meaningful change in Par 1.53.0 .\" Copyright 1993, 1996, 2000, 2020 Adam M. Costello .\" .\" This is nroff -man (or troff -man) code. .\" .TH par 1 "2020-Mar-14" "Par 1.53.0" "USER COMMANDS" .SH NAME par \- filter for reformatting paragraphs .SH SYNOPSIS .ds O \fR[\fP .ds C \fR]\fP .de OP .BI \*O\ \\$1 \\$2\ \*C .. .TP .5i .B par .na .OP help .OP version .OP B opset .OP P opset .OP Q opset .OP W opset .OP Z opset .OP h \*Ohang\*C .OP p \*Oprefix\*C .OP r \*Orepeat\*C .OP s \*Osuffix\*C .OP T \*OTab\*C .OP w \*Owidth\*C .OP b \*Obody\*C .OP c \*Ocap\*C .OP d \*Odiv\*C .OP E \*OErr\*C .OP e \*Oexpel\*C .OP f \*Ofit\*C .OP g \*Oguess\*C .OP j \*Ojust\*C .OP l \*Olast\*C .OP q \*Oquote\*C .OP R \*OReport\*C .OP t \*Otouch\*C .br .ad .SH DESCRIPTION .ie t .ds Q `` .el .ds Q "" .ie t .ds U '' .el .ds U "" .de IT .LP \h'-\w'\\$1\ 'u'\\$1\ \\$2 \\$3 \\$4 \\$5 \\$6 \\$7 \\$8 \\$9 .. .LP .B par is a filter which copies its input to its output, changing all white characters (except newlines) to spaces, and reformatting each paragraph. Paragraphs are separated by protected, blank, and bodiless lines (see the .SM TERMINOLOGY section for definitions), and optionally delimited by indentation (see the .B d option in the .SM OPTIONS section). .LP Each output paragraph is generated from the corresponding input paragraph as follows: .RS .LP .IT 1) An optional prefix and/or suffix is removed from each input line. .IT 2) The remainder is divided into words (separated by spaces). .IT 3) The words are joined into lines to make an eye-pleasing paragraph. .IT 4) The prefixes and suffixes are reattached. .RE .LP If there are suffixes, spaces are inserted before them so that they all end in the same column. .SH QUICK START .LP .B par is necessarily complex. For those who wish to use it immediately and understand it later, assign the .B \s-1PARINIT\s0 environment variable the following value: .IP rTbgqR B=.,?'_A_a_@ Q=_s>| .LP The spaces, question mark, apostrophe, greater-than sign, and vertical bar will probably have to be escaped or quoted to prevent your shell from interpreting them. .LP The documentation, though precise, is unfortunately not well-written for the end-user. Your best bet is probably to read quickly the .SM DESCRIPTION\s0, .SM TERMINOLOGY\s0, .SM OPTIONS\s0, and .SM ENVIRONMENT sections, then read carefully the .SM EXAMPLES section, referring back to the .SM OPTIONS and .SM TERMINOLOGY sections as needed. .LP For the \*Qpower user\*U, a full understanding of .B par will require multiple readings of the .SM TERMINOLOGY\s0, .SM OPTIONS\s0, .SM DETAILS\s0, and .SM EXAMPLES sections. .SH TERMINOLOGY .LP Miscellaneous terms: .RS .IP "charset syntax" A way of representing a set of characters as a string. The set includes exactly those characters which appear in the string, except that the underscore (_) is an escape character. Whenever it appears, it must begin one of the following escape sequences: .RS 1.5i .IT __\ = an underscore .IT _s\ = a space .IT _S\ = all space characters .IT _b\ = a backslash (\e) .IT _q\ = a single quote (') .IT _Q\ = a double quote (") .IT _A\ = all upper case letters .IT _a\ = all lower case letters .IT _@\ = all neither-case letters .IT _0\ = all decimal digits .IT _x\fIhh\fP\ = the character represented by the two hexadecimal digits .I hh (which may be upper or lower case) .RE .IP The NUL character must not appear in the string, but it may be included in the set with the _x00 sequence. .IP The exact meanings of _S, _A, _a, _@, and _0 are locale-dependent. (Actually, all locales are supposed to agree on _0, but not on the others.) In the default \*QC\*U locale: _S includes only space, formfeed, newline, carriage return, tab, and vertical tab; _A includes only A through Z; _a includes only a through z; _@ includes nothing; and _0 includes only 0 through 9. .IP error A condition which causes .B par to abort. See the .SM DIAGNOSTICS section. .IP IP Input paragraph. .IP OP Output paragraph. .IP parameter A symbol which may take on unsigned integral values. There are several parameters whose values affect the behavior of .BR par . Parameters can be assigned values using command line options. .RE .LP Types of characters: .RS .IP "alphanumeric character" An alphabetic character or decimal digit, _A_a_@_0 in charset syntax (see above). .IP "body character" A member of the set of characters defined by the .B \s-1PARBODY\s0 environment variable (see the .SM ENVIRONMENT section) and/or the .B B option (see the .SM OPTIONS section). .IP "protective character" A member of the set of characters defined by the .B \s-1PARPROTECT\s0 environment variable and/or the .B P option. .IP "quote character" A member of the set of characters defined by the .B \s-1PARQUOTE\s0 environment variable and/or the .B Q option. .IP "terminal character" A member of the set of characters defined by the .B Z option. Initially, before any .B Z options have been processed, the set contains period, question mark, exclamation point, and colon. .IP "white character" A member of the set of characters defined by the .B W option. Initially, before any .B W options have been processed, the set contains space, formfeed, newline, carriage return, tab, and vertical tab. .RE .LP Functions: .RS .IP comprelen Given a non-empty sequence .I S of lines, let .I c be their longest common prefix. If the parameter .I body is 0, place a divider just after the leading non-body characters in .I c (at the beginning if there are none). If .I body is 1, place the divider just after the last non-space non-body character in .I c (at the beginning if there is none), then advance the divider over any immediately following spaces. The comprelen of .I S is the number of characters preceding the divider. .IP comsuflen Given a non-empty sequence .I S of lines, let .I p be the comprelen of .IR S . Let .I T be the set of lines which result from stripping the first .I p characters from each line in .IR S . Let .I c be the longest common suffix of the lines in .IR T . If .I body is 0, place a divider just before the trailing non-body characters in .I c (at the end if there are none), then advance the divider over all but the last of any immediately following spaces. If .I body is 1, place the divider just before the first non-space non-body character, then back up the divider over one immediately preceding space if there is one. The comsuflen of .I S is the number of characters following the divider. .IP "fallback prelen (suflen)" The fallback prelen (suflen) of an IP is: the comprelen (comsuflen) of the IP, if the IP contains at least two lines; otherwise, the comprelen (comsuflen) of the block containing the IP, if the block contains at least two lines; otherwise, the length of the longer of the prefixes (suffixes) of the bodiless lines just above and below the block, if the segment containing the block has any bodiless lines; otherwise, 0. (See below for the definitions of block, segment, and bodiless line.) .IP "augmented fallback prelen" Let .I fp be the fallback prelen of an IP. If the IP contains more than one line, or if .I quote is 0, then the augmented fallback prelen of the IP is simply .IR fp . Otherwise, it is .I fp plus the number of quote characters immediately following the first .I fp characters of the line. .IP quoteprefix The quoteprefix of a line is the longest string of quote characters appearing at the beginning of the line, after this string has been stripped of any trailing spaces. .RE .LP Types of lines: .RS .IP "blank line" An empty line, or a line whose first character is not protective and which contains only spaces. .IP "protected line" An input line whose first character is protective. .IP "bodiless line" A line which is order .I k bodiless for some .IR k . .IP "order \fIk\fP bodiless line" There is no such thing as an order 0 bodiless line. Suppose .I S is a a contiguous subsequence of a segment (see below) containing at least two lines, containing no order .IR k \-1 bodiless lines, bounded above and below by order .IR k \-1 bodiless lines and/or the beginning/end of the segment. Let .I p and .I s be the comprelen and comsuflen of .IR S . Any member of .I S which, if stripped of its first .I p and last .I s characters, would be blank (or, if the line was not inserted by the .I quote feature and the parameter .I repeat is non-zero, would consist of the same character repeated at least .I repeat times), is order .I k bodiless. The first .I p characters of the bodiless line comprise its prefix; the last .I s characters comprise its suffix. The character which repeats in the middle is called its repeat character. If the middle is empty, the space is taken to be its repeat character. .IP "vacant line" A bodiless line whose repeat character is the space. .IP "superfluous line" Only blank and vacant lines may be superfluous. If contiguous vacant lines lie at the beginning or end of a segment, they are all superfluous. But if they lie between two non-vacant lines within a segment, then all are superfluous except one\(emthe one which contains the fewest non-spaces. In case of a tie, the first of the tied lines is chosen. Similarly, if contiguous blank lines lie outside of any segments at the beginning or end of the input, they are all superfluous. But if they lie between two segments and/or protected lines, then all are superfluous except the first. .RE .LP Groups of lines: .RS .IP segment A contiguous sequence of input lines containing no protected or blank lines, bounded above and below by protected lines, blank lines, and/or the beginning/end of the input. .IP block A contiguous subsequence of a segment containing no bodiless lines, bounded above and below by bodiless lines and/or the beginning/end of the segment. .RE .LP Types of words: .RS .IP "capitalized word" If the parameter .I cap is 0, a capitalized word is one which contains at least one alphanumeric character, whose first alphanumeric character is not a lower case letter. If .I cap is 1, every word is considered a capitalized word. (See the .B c option in the .SM OPTIONS section.) .IP "curious word" A word which contains a terminal character .I c such that there are no alphanumeric characters in the word after .IR c , but there is at least one alphanumeric character in the word before .IR c . .RE .SH OPTIONS .LP Any command line argument may begin with one minus sign (\-) which is ignored. Generally, more than one option may appear in a single command line argument, but there are exceptions: The .BR help , .BR version , .BR B , .BR P , and .B Q options must have whole arguments all to themselves. .TP 1i .B help Causes all remaining arguments to be ignored. No input is read. A usage message is printed on the output briefly describing the options used by .BR par . .TP .B version Causes all remaining arguments to be ignored. No input is read. \*Qpar \*U followed by its version number is printed on the output. .TP .BI B opset .I op is a single character, either an equal sign (=), a plus sign (+), or a minus sign (-), and .I set is a string using charset syntax. If .I op is an equal sign, the set of body characters is set to the character set defined by .IR set . If .I op is a plus/minus sign, the characters in the set defined by .I set are added/removed to/from the existing set of body characters defined by the .B \s-1PARBODY\s0 environment variable and any previous B options. It is okay to add characters that are already in the set or to remove characters that are not in the set. .TP .BI P opset Just like the .B B option, except that it applies to the set of protective characters. .TP .BI Q opset Just like the .B B option, except that it applies to the set of quote characters. .TP .BI W opset Just like the .B B option, except that it applies to the set of white characters. .TP .BI Z opset Just like the .B B option, except that it applies to the set of terminal characters. .LP All remaining options are used to set values of parameters. Values set by command line options hold for all paragraphs. Unset parameters are given default values. Any parameters whose default values depend on the IP (namely .I prefix and .IR suffix ), if left unset, are recomputed separately for each paragraph. .LP The approximate role of each variable is described here. See the .SM DETAILS section for the rest of the story. .LP The first six parameters, .IR hang , .IR prefix , .IR repeat , .IR suffix , .IR Tab , and .IR width , may be set to any unsigned decimal integer less than 10000. .TP 1i .BI h\fR[ hang\fR] Mainly affects the default values of .I prefix and .IR suffix . Defaults to 0. If the .B h option is given without a number, the value 1 is inferred. (See also the .B p and .B s options.) .TP .BI p\fR[ prefix\fR] The first .I prefix characters of each line of the OP are copied from the first .I prefix characters of the corresponding line of the IP. If there are more than .IR hang +1 lines in the IP, the default value is the comprelen of all the lines in the IP except the first .I hang of them. Otherwise, the default value is the augmented fallback prelen of the IP. If the .B p option is given without a number, .I prefix is unset, even if it had been set earlier. (See also the .B h and .B q options.) .TP .BI r\fR[ repeat\fR] If .I repeat is non-zero, bodiless lines have the number of instances of their repeat characters increased or decreased until the length of the line is .IR width . The exact value of .I repeat affects the definition of bodiless line. Defaults to 0. If the .B r option is given without a number, the value 3 is inferred. (See also the .B w option.) .TP .BI s\fR[ suffix\fR] The last .I suffix characters of each line of the OP are copied from the last .I suffix characters of the corresponding line of the IP. If there are more than .IR hang +1 lines in the IP, the default value is the comsuflen of all the lines of the IP except the first .I hang of them. Otherwise, the default value is the fallback suflen of the IP. If the .B s option is given without a number, .I suffix is unset, even if it had been set earlier. (See also the .B h option.) .TP .BI T\fR[ Tab\fR] Tab characters in the input are expanded to spaces, assuming tab stops every .I Tab columns. Must not be 0. Defaults to 1. If the .B T option is given without a number, the value 8 is inferred. .TP .BI w\fR[ width\fR] No line in the OP may contain more than .I width characters, not including the trailing newlines. Defaults to 72. If the .B w option is given without a number, the value 79 is inferred. .LP The remaining thirteen parameters, .IR body , .IR cap , .IR div , .IR Err , .IR expel , .IR fit , .IR guess , .IR invis , .IR just , .IR last , .IR quote , .IR Report , and .IR touch , may be set to either 0 or 1. If the number is absent in the option, the value 1 is inferred. .TP 1i .BI b\fR[ body\fR] If .I body is 1, prefixes may not contain any trailing body characters, and suffixes may not contain any leading body characters. (Actually, the situation is complicated by space characters. See comprelen and comsuflen in the Terminology section.) If .I body is 0, prefixes and suffixes may not contain any body characters at all. Defaults to 0. .TP .BI c\fR[ cap\fR] If .I cap is 1, all words are considered capitalized. This currently affects only the application of the .B g option. Defaults to 0. .TP .BI d\fR[ div\fR] If .I div is 0, each block becomes an IP. If .I div is 1, each block is subdivided into IPs as follows: Let .I p be the comprelen of the block. Let a line's status be 1 if its .RI ( p +1)st character is a space, 0 otherwise. Every line in the block whose status is the same as the status of the first line will begin a new paragraph. Defaults to 0. .TP .BI E\fR[ Err\fR] If .I Err is 1, messages to the user (caused by the .B help and .B version options, or by errors) are sent to the error stream instead of the output stream. Defaults to 0. .TP .BI e\fR[ expel\fR] If .I expel is 1, superfluous lines are withheld from the output. Defaults to 0. .TP .BI f\fR[ fit\fR] If .I fit is 1 and .I just is 0, .B par tries to make the lines in the OP as nearly the same length as possible, even if it means making the OP narrower. Defaults to 0. (See also the .B j option.) .TP .BI g\fR[ guess\fR] If .I guess is 1, then when .B par is choosing line breaks, whenever it encounters a curious word followed by a capitalized word, it takes one of two special actions. If the two words are separated by a single space in the input, they will be merged into one word with an embedded non-breaking space. If the two words are separated by more than one space, or by a line break, .B par will insure that they are separated by two spaces, or by a line break, in the output. Defaults to 0. .TP .BI i\fR[ invis\fR] If .I invis is 1, then vacant lines inserted because .I quote is 1 are invisible; that is, they are not output. If .I quote is 0, .I invis has no effect. Defaults to 0. (See also the .B q option.) .TP .BI j\fR[ just\fR] If .I just is 1, .B par justifies the OP, inserting spaces between words so that all lines in the OP have length .I width (except the last, if .I last is 0). Defaults to 0. (See also the .BR w , .BR l , and .B f options.) .TP .BI l\fR[ last\fR] If .I last is 1, .B par tries to make the last line of the OP about the same length as the others. Defaults to 0. .TP .BI q\fR[ quote\fR] If .I quote is 1, then before each segment is scanned for bodiless lines, .B par supplies vacant lines between different quotation nesting levels as follows: For each pair of adjacent lines in the segment, (scanned from the top down) which have different quoteprefixes, one of two actions is taken. If .I invis is 0, and either line consists entirely of quote characters and spaces (or is empty), that line is truncated to the longest common prefix of the two lines (both are truncated if both qualify). Otherwise, a line consisting of the longest common prefix of the two lines is inserted between them. .I quote also affects the default value of .IR prefix . Defaults to 0. (See also the .B p and .B i options.) .TP .BI R\fR[ Report\fR] If .I Report is 1, it is considered an error for an input word to contain more than .IR L \ = .RI ( width \ - .IR prefix \ - .IR suffix ) characters. Otherwise, such words are chopped after each .IR L th character into shorter words. Defaults to 0. .TP .BI t\fR[ touch\fR] Has no effect if .I suffix is 0 or .I just is 1. Otherwise, if .I touch is 0, all lines in the OP have length .IR width . If .I touch is 1, the length of the lines is decreased until the suffixes touch the body of the OP. Defaults to the logical .SM OR of .I fit and .IR last . (See also the .BR s , .BR j , .BR w , .BR f , and .B l options.) .LP If an argument begins with a number, that number is assumed to belong to a .B p option if it is 8 or less, and to a .B w option otherwise. .LP If the value of any parameter is set more than once, the last value is used. When unset parameters are assigned default values, .I hang and .I quote are assigned before .IR prefix , and .I fit and .I last are assigned before .I touch (because of the dependencies). .LP It is an error if .I width <= .I prefix + .IR suffix . .SH ENVIRONMENT .TP 1i .B \s-1PARBODY\s0 Determines the initial set of body characters (which are used for determining comprelens and comsuflens), using charset syntax. If .B \s-1PARBODY\s0 is not set, the set of body characters is initially empty. .TP .B \s-1PARINIT\s0 If set, .B par will read command line options from .B \s-1PARINIT\s0 before it reads them from the command line. Within the value of .B \s-1PARINIT\s0, arguments are separated by the initial set of white characters. .TP .B \s-1PARPROTECT\s0 Determines the set of protective characters, using charset syntax. If .B \s-1PARPROTECT\s0 is not set, the set of protective characters is initially empty. .TP .B \s-1PARQUOTE\s0 Determines the set of quote characters, using charset syntax. If .B \s-1PARQUOTE\s0 is not set, the set of quote characters initially contains only the greater-than sign (>) and the space. .LP If a .SM NUL character appears in the value of an environment variable, it and the rest of the string will not be seen by .BR par . .LP Note that the .B \s-1PARINIT\s0 variable, together with the .BR B , .BR P , and .B Q options, renders the other environment variables unnecessary. They are included for backward compatibility. .SH DETAILS .LP Lines are terminated by newline characters, but the newlines are not considered to be included in the lines. If the last character of the input is a non-newline, a newline will be inferred immediately after it (but if the input is empty, no newline will be inferred; the number of input lines will be 0). Thus, the input can always be viewed as a sequence of lines. .LP Protected lines are copied unchanged from the input to the output. All other input lines, as they are read, have any .SM NUL characters removed, and every white character (except newlines) turned into a space. Actually, each tab character is turned into .I Tab - .RI ( n % .IR Tab ) spaces, where .I n is the number of characters preceding the tab character on the line (evaluated after earlier tab characters have been expanded). .LP Blank lines in the input are transformed into empty lines in the output. .LP If .I repeat is 0, all bodiless lines are vacant, and they are all simply stripped of trailing spaces before being output. If .I repeat is not 0, only vacant lines whose suffixes have length 0 are treated that way; other bodiless lines have the number of instances of their repeat characters increased or decreased until the length of the line is .IR width . .LP If .I expel is 1, superfluous lines are not output. If .I quote and .I invis are both 1, there may be invisible lines; they are not output. .LP The input is divided into segments, which are divided into blocks, which are divided into IPs. The exact process depends on the values of .I quote and .I div (see .B q and .B d in the .SM OPTIONS section). The remainder of this section describes the process which is applied independently to each IP to construct the corresponding OP. .LP After the values of the parameters are determined (see the .SM OPTIONS section), the first .I prefix characters and the last .I suffix characters of each input line are removed and remembered. It is an error for any line to contain fewer than .IR prefix \ +\ suffix characters. .LP The remaining text is treated as a sequence of characters, not lines. The text is broken into words, which are separated by spaces. That is, a word is a maximal sub-sequence of non-spaces. If .I guess is 1, some words might be merged (see .B g in the .SM OPTIONS section). The first word includes any spaces that precede it on the same line. .LP Let .I L = .I width \- .I prefix \- .IR suffix . .LP If .I Report is 0, some words may get chopped up at this point (see .B R in the .SM OPTIONS section). .LP The words are reassembled, preserving their order, into lines. If .I just is 0, adjacent words within a line are separated by a single space, (or sometimes two if .I guess is 1), and line breaks are chosen so that the paragraph satisfies the following properties: .RS 1i .IT 1) No line contains more than .I L characters. .IT 2) If .I fit is 1, the difference between the lengths of the shortest and longest lines is as small as possible. .IT 3) The shortest line is as long as possible, subject to properties 1 and 2. .IT 4) Let .I target be .I L if .I fit is 0, or the length of the longest line if .I fit is 1. The sum of the squares of the differences between .I target and the lengths of the lines is as small as possible, subject to properties 1, 2, and 3. .RE .RS .5i .LP If .I last is 0, the last line does not count as a line for the purposes of properties 2, 3, and 4 above. .LP If all the words fit on a single line, the properties as worded above don't make much sense. In that case, no line breaks are inserted. .RE .LP If .I just is 1, adjacent words within a line are separated by one space (or sometimes two if .I guess is 1) plus zero or more extra spaces. The value of .I fit is disregarded, and line breaks are chosen so that the paragraph satisfies the following properties: .RS 1i .IT 1) Every line contains exactly .I L characters. .IT 2) The largest inter-word gap is as small as possible, subject to property 1. (An inter-word gap consists only of the extra spaces, not the regular spaces.) .IT 3) The sum of the squares of the lengths of the inter-word gaps is as small as possible, subject to properties 1 and 2. .RE .RS .5i .LP If .I last is 0, the last line does not count as a line for the purposes of property 1, and it does not require or contain any extra spaces. .LP Extra spaces are distributed as uniformly as possible among the inter-word gaps in each line. .LP In a justified paragraph, every line must contain at least two words, but that's not always possible to accomplish. If the paragraph cannot be justified, it is considered an error. .RE .LP If the number of lines in the resulting paragraph is less than .IR hang , empty lines are added at the end to bring the number of lines up to .IR hang . .LP If .I just is 0 and .I touch is 1, .I L is changed to be the length of the longest line. .LP If .I suffix is not 0, each line is padded at the end with spaces to bring its length up to .IR L . .LP To each line is prepended .I prefix characters. Let .I n be the number of lines in the IP, let .I afp be the augmented fallback prelen of the IP, and let .I fs be the fallback suflen of the IP. The characters which are prepended to the .IR i th line are chosen as follows: .RS .LP .IT 1) If .I i <= .IR n , the characters are copied from the ones that were removed from the beginning of the .IR n th input line. .IT 2) If .I i > .I n > .IR hang , the characters are copied from the ones that were removed from the beginning of the last input line. .IT 3) If .I i > .I n and .I n <= .IR hang , the first .RI min( afp , prefix ) of the characters are copied from the ones that were removed from the beginning of the last input line, and the rest are all spaces. .RE .LP Then to each line is appended .I suffix characters. The characters which are appended to the .IR i th line are chosen as follows: .RS .LP .IT 1) If .I i <= .IR n , the characters are copied from the ones that were removed from the end of the .IR n th input line. .IT 2) If .I i > .I n > .IR hang , the characters are copied from the ones that were removed from the end of the last input line. .IT 3) If .I i > .I n and .I n <= .IR hang , the first .RI min( fs , suffix ) of the characters are copied from the ones that were removed from the beginning of the last input line, and the rest are all spaces. .RE .LP Finally, the lines are printed to the output as the OP. .SH DIAGNOSTICS .LP If there are no errors, .B par returns .B \s-1EXIT_SUCCESS\s0 (see .BR ). .LP If there is an error, an error message will be printed to the output, and .B par will return .BR \s-1EXIT_FAILURE\s0 . If the error is local to a single paragraph, the preceding paragraphs will have been output before the error was detected. Line numbers in error messages are local to the IP in which the error occurred. All error messages begin with \*Qpar\ error:\*U on a line by itself. Error messages concerning command line or environment variable syntax are accompanied by the same usage message that the help option produces. .LP Of course, trying to print an error message would be futile if an error resulted from an output function, so .B par doesn't bother doing any error checking on output functions. .SH EXAMPLES .de VS .RS -.5i .LP .nf .ps -1p .vs -2p .ft CW .. .de VE .ft P .vs .ps .fi .RE .. .de CM \&\*Q\fB\\$1\fP\\*U: .. .LP The superiority of .BR par 's dynamic programming algorithm over a greedy algorithm (such as the one used by .BR fmt ) can be seen in the following example: .LP Original paragraph (note that each line begins with 8 spaces): .VS We the people of the United States, in order to form a more perfect union, establish justice, insure domestic tranquility, provide for the common defense, promote the general welfare, and secure the blessing of liberty to ourselves and our posterity, do ordain and establish the Constitution of the United States of America. .VE .LP After a greedy algorithm with width = 39: .VS We the people of the United States, in order to form a more perfect union, establish justice, insure domestic tranquility, provide for the common defense, promote the general welfare, and secure the blessing of liberty to ourselves and our posterity, do ordain and establish the Constitution of the United States of America. .VE .LP After .CM "par 39" .VS We the people of the United States, in order to form a more perfect union, establish justice, insure domestic tranquility, provide for the common defense, promote the general welfare, and secure the blessing of liberty to ourselves and our posterity, do ordain and establish the Constitution of the United States of America. .VE .LP The line breaks chosen by .B par are clearly more eye-pleasing. .LP .B par is most useful in conjunction with the text-filtering features of an editor, such as the ! commands of .BR vi . You may wish to add the following lines to your .B .exrc file: .VS " use Bourne shell for speed: set shell=/bin/sh " " reformat paragraph with no arguments: map ** {!}par^M} " " reformat paragraph with arguments: map *^V {!}par .VE .LP Note that the leading spaces must be removed, and that what is shown as ^M and ^V really need to be ctrl-M and ctrl-V. Also note that the last map command contains two spaces following the ctrl-V, plus one at the end of the line. .LP To reformat a simple paragraph delimited by blank lines in .BR vi , you can put the cursor anywhere in it and type \*Q\fB**\fP\*U (star star). If you need to supply arguments to par, you can type \*Q\fB*\ \fP\*U (star space) instead, then type the arguments. .LP The rest of this section is a series of before-and-after pictures showing some typical uses of .BR par . In all cases, no environment variables are set. .LP Before: .VS /* We the people of the United States, */ /* in order to form a more perfect union, */ /* establish justice, */ /* insure domestic tranquility, */ /* provide for the common defense, */ /* promote the general welfare, */ /* and secure the blessing of liberty */ /* to ourselves and our posterity, */ /* do ordain and establish the Constitution */ /* of the United States of America. */ .VE .LP After .CM "par 59" .VS /* We the people of the United States, in */ /* order to form a more perfect union, establish */ /* justice, insure domestic tranquility, provide */ /* for the common defense, promote the general */ /* welfare, and secure the blessing of liberty */ /* to ourselves and our posterity, do ordain */ /* and establish the Constitution of the United */ /* States of America. */ .VE .LP Or after .CM "par 59f" .VS /* We the people of the United States, */ /* in order to form a more perfect union, */ /* establish justice, insure domestic */ /* tranquility, provide for the common */ /* defense, promote the general welfare, */ /* and secure the blessing of liberty to */ /* ourselves and our posterity, do ordain */ /* and establish the Constitution of the */ /* United States of America. */ .VE .LP Or after .CM "par 59l" .VS /* We the people of the United States, in */ /* order to form a more perfect union, establish */ /* justice, insure domestic tranquility, */ /* provide for the common defense, promote */ /* the general welfare, and secure the */ /* blessing of liberty to ourselves and our */ /* posterity, do ordain and establish the */ /* Constitution of the United States of America. */ .VE .LP Or after .CM "par 59lf" .VS /* We the people of the United States, */ /* in order to form a more perfect union, */ /* establish justice, insure domestic */ /* tranquility, provide for the common */ /* defense, promote the general welfare, */ /* and secure the blessing of liberty */ /* to ourselves and our posterity, do */ /* ordain and establish the Constitution */ /* of the United States of America. */ .VE .LP Or after .CM "par 59lft0" .VS /* We the people of the United States, */ /* in order to form a more perfect union, */ /* establish justice, insure domestic */ /* tranquility, provide for the common */ /* defense, promote the general welfare, */ /* and secure the blessing of liberty */ /* to ourselves and our posterity, do */ /* ordain and establish the Constitution */ /* of the United States of America. */ .VE .LP Or after .CM "par 59j" .VS /* We the people of the United States, in */ /* order to form a more perfect union, establish */ /* justice, insure domestic tranquility, provide */ /* for the common defense, promote the general */ /* welfare, and secure the blessing of liberty */ /* to ourselves and our posterity, do ordain and */ /* establish the Constitution of the United */ /* States of America. */ .VE .LP Or after .CM "par 59jl" .VS /* We the people of the United States, */ /* in order to form a more perfect */ /* union, establish justice, insure domestic */ /* tranquility, provide for the common defense, */ /* promote the general welfare, and secure */ /* the blessing of liberty to ourselves and */ /* our posterity, do ordain and establish the */ /* Constitution of the United States of America. */ .VE .LP Before: .VS Preamble We the people of the United States, to the US in order to form Constitution a more perfect union, establish justice, insure domestic tranquility, provide for the common defense, promote the general welfare, and secure the blessing of liberty to ourselves and our posterity, do ordain and establish the Constitution of the United States of America. .VE .LP After .CM "par 52h3" .VS Preamble We the people of the United to the US States, in order to form a Constitution more perfect union, establish justice, insure domestic tranquility, provide for the common defense, promote the general welfare, and secure the blessing of liberty to ourselves and our posterity, do ordain and establish the Constitution of the United States of America. .VE .LP Before: .VS 1 We the people of the United States, 2 in order to form a more perfect union, 3 establish justice, 4 insure domestic tranquility, 5 provide for the common defense, 6 promote the general welfare, 7 and secure the blessing of liberty 8 to ourselves and our posterity, 9 do ordain and establish the Constitution 10 of the United States of America. .VE .LP After .CM "par 59p12l" .VS 1 We the people of the United States, in order to 2 form a more perfect union, establish justice, 3 insure domestic tranquility, provide for the 4 common defense, promote the general welfare, 5 and secure the blessing of liberty to ourselves 6 and our posterity, do ordain and establish the 7 Constitution of the United States of America. .VE .LP Before: .VS > > We the people > > of the United States, > > in order to form a more perfect union, > > establish justice, > > ensure domestic tranquility, > > provide for the common defense, > > Promote the general welfare, > and secure the blessing of liberty > to ourselves and our posterity, > do ordain and establish > the Constitution of the United States of America. .VE .LP After .CM "par 52" .VS > > We the people of the United States, in > > order to form a more perfect union, > > establish justice, ensure domestic > > tranquility, provide for the common > > defense, > > Promote the general welfare, and secure > the blessing of liberty to ourselves and > our posterity, do ordain and establish > the Constitution of the United States of > America. .VE .LP Before: .VS > We the people > of the United States, > in order to form a more perfect union, > establish justice, > ensure domestic tranquility, > provide for the common defense, > Promote the general welfare, > and secure the blessing of liberty > to ourselves and our posterity, > do ordain and establish > the Constitution of the United States of America. .VE .LP After .CM "par 52d" .VS > We the people of the United States, > in order to form a more perfect union, > establish justice, ensure domestic > tranquility, provide for the common > defense, > Promote the general welfare, and secure > the blessing of liberty to ourselves and > our posterity, do ordain and establish > the Constitution of the United States of > America. .VE .LP Before: .VS # 1. We the people of the United States. # 2. In order to form a more perfect union. # 3. Establish justice, ensure domestic # tranquility. # 4. Provide for the common defense # 5. Promote the general welfare. # 6. And secure the blessing of liberty # to ourselves and our posterity. # 7. Do ordain and establish the Constitution. # 8. Of the United States of America. .VE .LP After .CM "par 37p13dh" .VS # 1. We the people of the # United States. # 2. In order to form a more # perfect union. # 3. Establish justice, # ensure domestic # tranquility. # 4. Provide for the common # defense # 5. Promote the general # welfare. # 6. And secure the blessing # of liberty to ourselves # and our posterity. # 7. Do ordain and establish # the Constitution. # 8. Of the United States of # America. .VE .LP Before: .VS /*****************************************/ /* We the people of the United States, */ /* in order to form a more perfect union, */ /* establish justice, insure domestic */ /* tranquility, */ /* */ /* */ /* [ provide for the common defense, ] */ /* [ promote the general welfare, ] */ /* [ and secure the blessing of liberty ] */ /* [ to ourselves and our posterity, ] */ /* [ ] */ /* */ /* do ordain and establish the Constitution */ /* of the United States of America. */ /******************************************/ .VE .LP After .CM "par 42r" .VS /********************************/ /* We the people of the */ /* United States, in order to */ /* form a more perfect union, */ /* establish justice, insure */ /* domestic tranquility, */ /* */ /* */ /* [ provide for the common ] */ /* [ defense, promote the ] */ /* [ general welfare, and ] */ /* [ secure the blessing of ] */ /* [ liberty to ourselves ] */ /* [ and our posterity, ] */ /* [ ] */ /* */ /* do ordain and establish the */ /* Constitution of the United */ /* States of America. */ /********************************/ .VE .LP Or after .CM "par 42re" .VS /********************************/ /* We the people of the */ /* United States, in order to */ /* form a more perfect union, */ /* establish justice, insure */ /* domestic tranquility, */ /* */ /* [ provide for the common ] */ /* [ defense, promote the ] */ /* [ general welfare, and ] */ /* [ secure the blessing of ] */ /* [ liberty to ourselves ] */ /* [ and our posterity, ] */ /* */ /* do ordain and establish the */ /* Constitution of the United */ /* States of America. */ /********************************/ .VE .LP Before: .VS Joe Public writes: > Jane Doe writes: > > > > > > I can't find the source for uncompress. > Oh no, not again!!! > > > Isn't there a FAQ for this? > > That wasn't very helpful, Joe. Jane, just make a link from uncompress to compress. .VE .LP After .CM "par 40q" .VS Joe Public writes: > Jane Doe writes: > > > > I can't find the source for > > uncompress. > > Oh no, not again!!! > > > Isn't there a FAQ for this? > That wasn't very helpful, Joe. Jane, just make a link from uncompress to compress. .VE .LP Or after .CM "par 40qe" .VS Joe Public writes: > Jane Doe writes: > > > I can't find the source for > > uncompress. > > Oh no, not again!!! > > Isn't there a FAQ for this? That wasn't very helpful, Joe. Jane, just make a link from uncompress to compress. .VE .LP Or after .CM "par 40qi" .VS Joe Public writes: > Jane Doe writes: > > > > > > I can't find the source for > > uncompress. > Oh no, not again!!! > > > Isn't there a FAQ for this? > > That wasn't very helpful, Joe. Jane, just make a link from uncompress to compress. .VE .LP Or after .CM "par 40qie" .VS Joe Public writes: > Jane Doe writes: > > I can't find the source for > > uncompress. > Oh no, not again!!! > > Isn't there a FAQ for this? That wasn't very helpful, Joe. Jane, just make a link from uncompress to compress. .VE .LP Before: .VS I sure hope there's still room in Dr. Jones' section of archaeology. I've heard he's the bestest. [sic] .VE .LP After .CM "par 50g" .VS I sure hope there's still room in Dr. Jones' section of archaeology. I've heard he's the bestest. [sic] .VE .LP Or after .CM "par 50gc" .VS I sure hope there's still room in Dr. Jones' section of archaeology. I've heard he's the bestest. [sic] .VE .LP Before: .VS John writes: : Mary writes: : + Anastasia writes: : + > Hi all! : + Hi Ana! : Hi Ana & Mary! Please unsubscribe me from alt.hello. .VE .LP After .CM "par Q+:+ q" .VS John writes: : Mary writes: : : + Anastasia writes: : + : + > Hi all! : + : + Hi Ana! : : Hi Ana & Mary! Please unsubscribe me from alt.hello. .VE .LP Before: .VS amc> The b option was added primarily to deal with amc> this new style of quotation amc> which became popular after Par 1.41 was released. amc> amc> Par still pays attention to body characters. amc> Par should not mistake "Par" for part of the prefix. amc> Par should not mistake "." for a suffix. .VE .LP After .CM "par B=._A_a 50bg" .VS amc> The b option was added primarily to amc> deal with this new style of quotation amc> which became popular after Par 1.41 amc> was released. amc> amc> Par still pays attention to body amc> characters. Par should not mistake amc> "Par" for part of the prefix. Par amc> should not mistake "." for a suffix. .VE .SH SEE ALSO .LP .B par.doc .SH LIMITATIONS .LP The .I guess feature guesses wrong in cases like the following: .VS I calc'd the approx. Fermi level to 3 sig. digits. .VE .LP With .I guess = 1, .B par will incorrectly assume that \*Qapprox.\*U ends a sentence. If the input were: .VS I calc'd the approx. Fermi level to 3 sig. digits. .VE .LP then .B par would refuse to put a line break between \*Qapprox.\*U and \*QFermi\*U in the output, mainly to avoid creating the first situation (in case the paragraph were to be fed back through .B par again). This non-breaking space policy does come in handy for cases like \*QMr.\ Johnson\*U and \*QJan.\ 1\*U, though. .LP The .I guess feature only goes one way. .B par can preserve wide sentence breaks in a paragraph, or remove them, but it can't insert them if they aren't already in the input. .LP If you use tabs, you may not like the way .B par handles (or doesn't handle) them. It expands them into spaces. I didn't let .B par output tabs because tabs don't make sense. Not everyone's terminal has the same tab settings, so text files containing tabs are sometimes mangled. In fact, almost every text file containing tabs gets mangled when something is inserted at the beginning of each line (when quoting e-mail or commenting out a section of a shell script, for example), making them a pain to edit. In my opinion, the world would be a nicer place if everyone stopped using tabs, so I'm doing my part by not letting .B par output them. (Thanks to Eric Stuebe for showing me the light about tabs.) .LP There is currently no way for the length of the output prefix to differ from the length of the input prefix. Ditto for the suffix. I may consider adding this capability in a future release, but right now I'm not sure how I'd want it to work. .SH APOLOGIES .LP Par began in July 1993 as a small program designed to do one narrow task: reformat a single paragraph that might have a border on either side. It was pretty clean back then. Over the next three months, it very rapidly expanded to handle multiple paragraphs, offer more options, and take better guesses, at the cost of becoming extremely complex, and very unclean. It is nowhere near the optimal design for the larger task it now tries to address. Its only redeeming features are that it is extremely useful (I find it indispensable), extremely portable, and very stable since version 1.41 released on 1993-Oct-31. .LP Back in 1993 I had very little experience at writing documentation for users, so the documentation for Par became rather nightmarish. There is no separation between how-it-works (which is painfully complex) and how-to-use-it (which is fairly simple, if you can ever figure it out). .LP Someday I ought to reexamine the problem, and redesign a new, clean solution from scratch. I don't know when I might get enough free time to start on such a project. Text files may be obsolete by then. .SH BUGS .LP If I knew of any bugs, I wouldn't release the package. Of course, there may be bugs that I haven't yet discovered. .LP If you find any bugs (in the program or in the documentation), or if you have any suggestions, please contact me: .RS .LP http://www.nicemice.net/amc/ .RE .LP When reporting a bug, please include the exact input and command line options used, and the version number of .BR par , so that I can reproduce it. .LP The latest release of Par is available on the Web at: .RS .LP http://www.nicemice.net/par/ .RE .LP I don't expect these URLs to change in the forseeable future, but if they do, I'll try to leave forward pointers. Par-1.53.0/test-par0000700000175000037200000004677513633246754012127 0ustar amceng: # test-par # last touched in Par 1.53.0 # last meaningful change in Par 1.53.0 # Copyright 2020 Adam M. Costello # This is POSIX shell code. if [ $# -ne 1 ]; then echo 'need exactly one argument, the pathname for par' >&2 exit 2 fi par=$1 unset PARBODY PARINIT PARPROTECT PARQUOTE pass_count=0 fail_count=0 # The caller must set variables called 'input' and 'expected', may set # a variable called 'locale' (which if nonempty will be exposed to # par as environment variable LC_ALL), and may pass arguments for par # on the command line. The input and expected text need not end with # newlines, because test_par will add a newline to the input, and the # shell backquotes that capture the output will strip the last newline. test_par() { output=` if [ -n "$locale" ]; then LC_ALL=$locale "$par" "$@" else "$par" "$@" fi << EOF $input EOF ` cmdline="${locale:+LC_ALL=$locale }$par $@" if [ "$expected" = "$output" ]; then pass_count=`expr $pass_count + 1` echo "passed: $cmdline" else fail_count=`expr $fail_count + 1` echo " FAILED: $cmdline input { $input } expected { $expected } output { $output } " fi } # From the Examples section of par.doc: input=`cat << 'EOF' We the people of the United States, in order to form a more perfect union, establish justice, insure domestic tranquility, provide for the common defense, promote the general welfare, and secure the blessing of liberty to ourselves and our posterity, do ordain and establish the Constitution of the United States of America. EOF ` args=39 expected=`cat << 'EOF' We the people of the United States, in order to form a more perfect union, establish justice, insure domestic tranquility, provide for the common defense, promote the general welfare, and secure the blessing of liberty to ourselves and our posterity, do ordain and establish the Constitution of the United States of America. EOF ` test_par $args input=`cat << 'EOF' /* We the people of the United States, */ /* in order to form a more perfect union, */ /* establish justice, */ /* insure domestic tranquility, */ /* provide for the common defense, */ /* promote the general welfare, */ /* and secure the blessing of liberty */ /* to ourselves and our posterity, */ /* do ordain and establish the Constitution */ /* of the United States of America. */ EOF ` args=59 expected=`cat << 'EOF' /* We the people of the United States, in */ /* order to form a more perfect union, establish */ /* justice, insure domestic tranquility, provide */ /* for the common defense, promote the general */ /* welfare, and secure the blessing of liberty */ /* to ourselves and our posterity, do ordain */ /* and establish the Constitution of the United */ /* States of America. */ EOF ` test_par $args args=59f expected=`cat << 'EOF' /* We the people of the United States, */ /* in order to form a more perfect union, */ /* establish justice, insure domestic */ /* tranquility, provide for the common */ /* defense, promote the general welfare, */ /* and secure the blessing of liberty to */ /* ourselves and our posterity, do ordain */ /* and establish the Constitution of the */ /* United States of America. */ EOF ` test_par $args args=59l expected=`cat << 'EOF' /* We the people of the United States, in */ /* order to form a more perfect union, establish */ /* justice, insure domestic tranquility, */ /* provide for the common defense, promote */ /* the general welfare, and secure the */ /* blessing of liberty to ourselves and our */ /* posterity, do ordain and establish the */ /* Constitution of the United States of America. */ EOF ` test_par $args args=59lf expected=`cat << 'EOF' /* We the people of the United States, */ /* in order to form a more perfect union, */ /* establish justice, insure domestic */ /* tranquility, provide for the common */ /* defense, promote the general welfare, */ /* and secure the blessing of liberty */ /* to ourselves and our posterity, do */ /* ordain and establish the Constitution */ /* of the United States of America. */ EOF ` test_par $args args=59lft0 expected=`cat << 'EOF' /* We the people of the United States, */ /* in order to form a more perfect union, */ /* establish justice, insure domestic */ /* tranquility, provide for the common */ /* defense, promote the general welfare, */ /* and secure the blessing of liberty */ /* to ourselves and our posterity, do */ /* ordain and establish the Constitution */ /* of the United States of America. */ EOF ` test_par $args args=59j expected=`cat << 'EOF' /* We the people of the United States, in */ /* order to form a more perfect union, establish */ /* justice, insure domestic tranquility, provide */ /* for the common defense, promote the general */ /* welfare, and secure the blessing of liberty */ /* to ourselves and our posterity, do ordain and */ /* establish the Constitution of the United */ /* States of America. */ EOF ` test_par $args args=59jl expected=`cat << 'EOF' /* We the people of the United States, */ /* in order to form a more perfect */ /* union, establish justice, insure domestic */ /* tranquility, provide for the common defense, */ /* promote the general welfare, and secure */ /* the blessing of liberty to ourselves and */ /* our posterity, do ordain and establish the */ /* Constitution of the United States of America. */ EOF ` test_par $args input=`cat << 'EOF' Preamble We the people of the United States, to the US in order to form Constitution a more perfect union, establish justice, insure domestic tranquility, provide for the common defense, promote the general welfare, and secure the blessing of liberty to ourselves and our posterity, do ordain and establish the Constitution of the United States of America. EOF ` args=52h3 expected=`cat << 'EOF' Preamble We the people of the United to the US States, in order to form a Constitution more perfect union, establish justice, insure domestic tranquility, provide for the common defense, promote the general welfare, and secure the blessing of liberty to ourselves and our posterity, do ordain and establish the Constitution of the United States of America. EOF ` test_par $args input=`cat << 'EOF' 1 We the people of the United States, 2 in order to form a more perfect union, 3 establish justice, 4 insure domestic tranquility, 5 provide for the common defense, 6 promote the general welfare, 7 and secure the blessing of liberty 8 to ourselves and our posterity, 9 do ordain and establish the Constitution 10 of the United States of America. EOF ` args=59p12l expected=`cat << 'EOF' 1 We the people of the United States, in order to 2 form a more perfect union, establish justice, 3 insure domestic tranquility, provide for the 4 common defense, promote the general welfare, 5 and secure the blessing of liberty to ourselves 6 and our posterity, do ordain and establish the 7 Constitution of the United States of America. EOF ` test_par $args input=`cat << 'EOF' > > We the people > > of the United States, > > in order to form a more perfect union, > > establish justice, > > ensure domestic tranquility, > > provide for the common defense, > > Promote the general welfare, > and secure the blessing of liberty > to ourselves and our posterity, > do ordain and establish > the Constitution of the United States of America. EOF ` args=52 expected=`cat << 'EOF' > > We the people of the United States, in > > order to form a more perfect union, > > establish justice, ensure domestic > > tranquility, provide for the common > > defense, > > Promote the general welfare, and secure > the blessing of liberty to ourselves and > our posterity, do ordain and establish > the Constitution of the United States of > America. EOF ` test_par $args input=`cat << 'EOF' > We the people > of the United States, > in order to form a more perfect union, > establish justice, > ensure domestic tranquility, > provide for the common defense, > Promote the general welfare, > and secure the blessing of liberty > to ourselves and our posterity, > do ordain and establish > the Constitution of the United States of America. EOF ` args=52d expected=`cat << 'EOF' > We the people of the United States, > in order to form a more perfect union, > establish justice, ensure domestic > tranquility, provide for the common > defense, > Promote the general welfare, and secure > the blessing of liberty to ourselves and > our posterity, do ordain and establish > the Constitution of the United States of > America. EOF ` test_par $args input=`cat << 'EOF' # 1. We the people of the United States. # 2. In order to form a more perfect union. # 3. Establish justice, ensure domestic # tranquility. # 4. Provide for the common defense # 5. Promote the general welfare. # 6. And secure the blessing of liberty # to ourselves and our posterity. # 7. Do ordain and establish the Constitution. # 8. Of the United States of America. EOF ` args=37p13dh expected=`cat << 'EOF' # 1. We the people of the # United States. # 2. In order to form a more # perfect union. # 3. Establish justice, # ensure domestic # tranquility. # 4. Provide for the common # defense # 5. Promote the general # welfare. # 6. And secure the blessing # of liberty to ourselves # and our posterity. # 7. Do ordain and establish # the Constitution. # 8. Of the United States of # America. EOF ` test_par $args input=`cat << 'EOF' /*****************************************/ /* We the people of the United States, */ /* in order to form a more perfect union, */ /* establish justice, insure domestic */ /* tranquility, */ /* */ /* */ /* [ provide for the common defense, ] */ /* [ promote the general welfare, ] */ /* [ and secure the blessing of liberty ] */ /* [ to ourselves and our posterity, ] */ /* [ ] */ /* */ /* do ordain and establish the Constitution */ /* of the United States of America. */ /******************************************/ EOF ` args=42r expected=`cat << 'EOF' /********************************/ /* We the people of the */ /* United States, in order to */ /* form a more perfect union, */ /* establish justice, insure */ /* domestic tranquility, */ /* */ /* */ /* [ provide for the common ] */ /* [ defense, promote the ] */ /* [ general welfare, and ] */ /* [ secure the blessing of ] */ /* [ liberty to ourselves ] */ /* [ and our posterity, ] */ /* [ ] */ /* */ /* do ordain and establish the */ /* Constitution of the United */ /* States of America. */ /********************************/ EOF ` test_par $args args=42re expected=`cat << 'EOF' /********************************/ /* We the people of the */ /* United States, in order to */ /* form a more perfect union, */ /* establish justice, insure */ /* domestic tranquility, */ /* */ /* [ provide for the common ] */ /* [ defense, promote the ] */ /* [ general welfare, and ] */ /* [ secure the blessing of ] */ /* [ liberty to ourselves ] */ /* [ and our posterity, ] */ /* */ /* do ordain and establish the */ /* Constitution of the United */ /* States of America. */ /********************************/ EOF ` test_par $args input=`cat << 'EOF' Joe Public writes: > Jane Doe writes: > > > > > > I can't find the source for uncompress. > Oh no, not again!!! > > > Isn't there a FAQ for this? > > That wasn't very helpful, Joe. Jane, just make a link from uncompress to compress. EOF ` args=40q expected=`cat << 'EOF' Joe Public writes: > Jane Doe writes: > > > > I can't find the source for > > uncompress. > > Oh no, not again!!! > > > Isn't there a FAQ for this? > That wasn't very helpful, Joe. Jane, just make a link from uncompress to compress. EOF ` test_par $args args=40qe expected=`cat << 'EOF' Joe Public writes: > Jane Doe writes: > > > I can't find the source for > > uncompress. > > Oh no, not again!!! > > Isn't there a FAQ for this? That wasn't very helpful, Joe. Jane, just make a link from uncompress to compress. EOF ` test_par $args args=40qi expected=`cat << 'EOF' Joe Public writes: > Jane Doe writes: > > > > > > I can't find the source for > > uncompress. > Oh no, not again!!! > > > Isn't there a FAQ for this? > > That wasn't very helpful, Joe. Jane, just make a link from uncompress to compress. EOF ` test_par $args args=40qie expected=`cat << 'EOF' Joe Public writes: > Jane Doe writes: > > I can't find the source for > > uncompress. > Oh no, not again!!! > > Isn't there a FAQ for this? That wasn't very helpful, Joe. Jane, just make a link from uncompress to compress. EOF ` test_par $args input=`cat << 'EOF' I sure hope there's still room in Dr. Jones' section of archaeology. I've heard he's the bestest. [sic] EOF ` args=50g expected=`cat << 'EOF' I sure hope there's still room in Dr. Jones' section of archaeology. I've heard he's the bestest. [sic] EOF ` test_par $args args=50gc expected=`cat << 'EOF' I sure hope there's still room in Dr. Jones' section of archaeology. I've heard he's the bestest. [sic] EOF ` test_par $args input=`cat << 'EOF' John writes: : Mary writes: : + Anastasia writes: : + > Hi all! : + Hi Ana! : Hi Ana & Mary! Please unsubscribe me from alt.hello. EOF ` args='Q+:+ q' expected=`cat << 'EOF' John writes: : Mary writes: : : + Anastasia writes: : + : + > Hi all! : + : + Hi Ana! : : Hi Ana & Mary! Please unsubscribe me from alt.hello. EOF ` test_par $args input=`cat << 'EOF' amc> The b option was added primarily to deal with amc> this new style of quotation amc> which became popular after Par 1.41 was released. amc> amc> Par still pays attention to body characters. amc> Par should not mistake "Par" for part of the prefix. amc> Par should not mistake "." for a suffix. EOF ` args='B=._A_a 50bg' expected=`cat << 'EOF' amc> The b option was added primarily to amc> deal with this new style of quotation amc> which became popular after Par 1.41 amc> was released. amc> amc> Par still pays attention to body amc> characters. Par should not mistake amc> "Par" for part of the prefix. Par amc> should not mistake "." for a suffix. EOF ` test_par $args # Tests for new features in 1.53.0: tmpdir=/tmp/test-par-$$ export LOCPATH=$tmpdir/locale mkdir -p $LOCPATH/en_US mkdir $LOCPATH/he_IL localedef -f ISO-8859-1 -i en_US $LOCPATH/en_US localedef -f ISO-8859-8 -i he_IL $LOCPATH/he_IL # ISO-8859-1 capital letters A and AE, small letters A and AE input=`printf 'A\306a\346'` # args= locale=C expected=$input test_par $args locale=en_US expected=$input test_par $args # args=W=_A locale=C expected=`printf ' \306a\346'` test_par $args locale=en_US expected=`printf ' a\346'` test_par $args # args=W=_a locale=C expected=`printf 'A\306 \346'` test_par $args locale=en_US expected=`printf 'A\306'` test_par $args # ISO-8859-1 no-break spaces and vertical tabs input=`printf 'X\240\240\240Y\v\v\vZ'` # args= locale=C expected=`printf 'X\240\240\240Y Z'` test_par $args locale=en_US test_par $args # args=W=_S locale=C expected=`printf 'X\240\240\240Y Z'` test_par $args # args=W= locale=en_US expected=$input test_par $args # # The behavior of isspace() on non-ASCII characters (like no-break # space) in locales other than C is not standardized, and has been # observed to vary, so we won't test that. If you want to refer to # no-break space, the surest way is with _x. args=W+_xA0 locale=en_US expected='X Y Z' test_par $args # ISO-8859-8 letter alef input=`printf '.\n\340'` # args=P=_A_a locale=he_IL expected=`printf '. \340'` test_par $args # args=P=_@ expected=`printf '.\n\340'` test_par $args unset LOCPATH locale input=`cat << 'EOF' > one >> two >>> three >>>> four >>>>> five EOF ` args='Q=> qr' expected=`cat << 'EOF' > one > >> two >> >>> three >>> >>>> four >>>> >>>>> five EOF ` test_par $args input=`cat << 'EOF' One. Two: Three. EOF ` args=g expected=`cat << 'EOF' One. Two: Three. EOF ` test_par $args # args='g Z-:' expected=`cat << 'EOF' One. Two: Three. EOF ` test_par $args rm -rf $tmpdir echo echo "$pass_count passed" echo "$fail_count failed" [ 0 = $fail_count ] Par-1.53.0/errmsg.c0000600000175000037200000000055613633274641012066 0ustar amceng/* errmsg.c last touched in Par 1.53.0 last meaningful change in Par 1.40 Copyright 1993 Adam M. Costello This is ANSI C code (C89). */ #include "errmsg.h" /* Makes sure we're consistent with the declarations. */ const char * const outofmem = "Out of memory.\n"; const char * const impossibility = "Impossibility #%d has occurred. Please report it.\n"; Par-1.53.0/charset.h0000600000175000037200000000347213633241067012221 0ustar amceng/* charset.h last touched in Par 1.53.0 last meaningful change in Par 1.31 Copyright 1993 Adam M. Costello This is ANSI C code (C89). Note: Those functions declared here which do not use errmsg always succeed, provided that they are passed valid arguments. */ #ifndef CHARSET_H #define CHARSET_H #include "errmsg.h" typedef struct charset charset; charset *parsecharset(const char *str, errmsg_t errmsg); /* parsecharset(str,errmsg) returns the set of characters defined by */ /* str using charset syntax (see par.doc). Returns NULL on failure. */ void freecharset(charset *cset); /* freecharset(cset) frees any memory associated with */ /* *cset. cset may not be used after this call. */ int csmember(char c, const charset *cset); /* csmember(c,cset) returns 1 if c is a member of *cset, 0 otherwise. */ charset *csunion(const charset *cset1, const charset *cset2, errmsg_t errmsg); /* csunion(cset1,cset2) returns a pointer to the */ /* union of *cset1 and *cset2, or NULL on failure. */ charset *csdiff(const charset *cset1, const charset *cset2, errmsg_t errmsg); /* csdiff(cset1,cset2) returns a pointer to the set */ /* difference *cset1 - *cset2 , or NULL on failure. */ void csadd(charset *cset1, const charset *cset2, errmsg_t errmsg); /* csadd(cset1,cset2) adds the members of *cset2 */ /* to *cset1. On failure, *cset1 is not changed. */ void csremove(charset *cset1, const charset *cset2, errmsg_t errmsg); /* csremove(cset1,cset2) removes the members of *cset2 */ /* from *cset1. On failure, *cset1 is not changed. */ charset *cscopy(const charset *cset, errmsg_t errmsg); /* cscopy(cset) returns a copy of cset, or NULL on failure. */ void csswap(charset *cset1, charset *cset2); /* csswap(cset1,cset2) swaps the contents of *cset1 and *cset2. */ #endif Par-1.53.0/reformat.c0000600000175000037200000003520413633242442012376 0ustar amceng/* reformat.c last touched in Par 1.53.0 last meaningful change in Par 1.53.0 Copyright 1993, 2001, 2020 Adam M. Costello This is ANSI C code (C89). The issues regarding char and unsigned char are relevant to the use of the ctype.h functions. See the comments near the beginning of par.c. */ #include "reformat.h" /* Makes sure we're consistent with the prototype. */ #include "buffer.h" #include "charset.h" #include "errmsg.h" #include #include #include #include #include #undef NULL #define NULL ((void *) 0) #ifdef DONTFREE #define free(ptr) #endif typedef unsigned char wflag_t; typedef struct word { const char *chrs; /* Pointer to the characters in the word */ /* (NOT terminated by '\0'). */ struct word *prev, /* Pointer to previous word. */ *next, /* Pointer to next word. */ /* Supposing this word were the first... */ *nextline; /* Pointer to first word in next line. */ int score, /* Value of the objective function. */ length; /* Length of this word. */ wflag_t flags; /* Notable properties of this word. */ } word; /* The following may be bitwise-OR'd together */ /* to set the flags field of a word: */ static const wflag_t W_SHIFTED = 1, /* This word should have an extra space before */ /* it unless it's the first word in the line. */ W_CURIOUS = 2, /* This is a curious word (see par.doc). */ W_CAPITAL = 4; /* This is a capitalized word (see par.doc). */ #define isshifted(w) ( (w)->flags & 1) #define iscurious(w) (((w)->flags & 2) != 0) #define iscapital(w) (((w)->flags & 4) != 0) static int checkcapital(word *w) /* Returns 1 if *w is capitalized according to the definition */ /* in par.doc (assuming is 0), or 0 if not. */ { const char *p, *end; for (p = w->chrs, end = p + w->length; p < end && !isalnum(*(unsigned char *)p); ++p); return p < end && !islower(*(unsigned char *)p); } static int checkcurious(word *w, const charset *terminalchars) /* Returns 1 if *w is curious according to */ /* the definition in par.doc, or 0 if not. */ { const char *start, *p; char ch; for (start = w->chrs, p = start + w->length; p > start; --p) { ch = p[-1]; if (isalnum(*(unsigned char *)&ch)) return 0; if (csmember(ch,terminalchars)) break; } if (p <= start + 1) return 0; --p; do if (isalnum(*(unsigned char *)--p)) return 1; while (p > start); return 0; } static int simplebreaks(word *head, word *tail, int L, int last) /* Chooses line breaks in a list of words which maximize the length of the */ /* shortest line. L is the maximum line length. The last line counts as a */ /* line only if last is non-zero. _head must point to a dummy word, and tail */ /* must point to the last word, whose next field must be NULL. Returns the */ /* length of the shortest line on success, -1 if there is a word of length */ /* greater than L, or L if there are no lines. */ { word *w1, *w2; int linelen, score; if (!head->next) return L; for (w1 = tail, linelen = w1->length; w1 != head && linelen <= L; linelen += isshifted(w1), w1 = w1->prev, linelen += 1 + w1->length) { w1->score = last ? linelen : L; w1->nextline = NULL; } for ( ; w1 != head; w1 = w1->prev) { w1->score = -1; for (linelen = w1->length, w2 = w1->next; linelen <= L; linelen += 1 + isshifted(w2) + w2->length, w2 = w2->next) { score = w2->score; if (linelen < score) score = linelen; if (score >= w1->score) { w1->nextline = w2; w1->score = score; } } } return head->next->score; } static void normalbreaks( word *head, word *tail, int L, int fit, int last, errmsg_t errmsg ) /* Chooses line breaks in a list of words according to the policy */ /* in "par.doc" for = 0 (L is , fit is , and last is */ /* ). head must point to a dummy word, and tail must point */ /* to the last word, whose next field must be NULL. */ { word *w1, *w2; int tryL, shortest, score, target, linelen, extra, minlen; *errmsg = '\0'; if (!head->next) return; target = L; /* Determine minimum possible difference between */ /* the lengths of the shortest and longest lines: */ if (fit) { score = L + 1; for (tryL = L; ; --tryL) { shortest = simplebreaks(head,tail,tryL,last); if (shortest < 0) break; if (tryL - shortest < score) { target = tryL; score = target - shortest; } } } /* Determine maximum possible length of the shortest line: */ shortest = simplebreaks(head,tail,target,last); if (shortest < 0) { sprintf(errmsg,impossibility,1); return; } /* Minimize the sum of the squares of the differences */ /* between target and the lengths of the lines: */ w1 = tail; do { w1->score = -1; for (linelen = w1->length, w2 = w1->next; linelen <= target; linelen += 1 + isshifted(w2) + w2->length, w2 = w2->next) { extra = target - linelen; minlen = shortest; if (w2) score = w2->score; else { score = 0; if (!last) extra = minlen = 0; } if (linelen >= minlen && score >= 0) { score += extra * extra; if (w1->score < 0 || score <= w1->score) { w1->nextline = w2; w1->score = score; } } if (!w2) break; } w1 = w1->prev; } while (w1 != head); if (head->next->score < 0) sprintf(errmsg,impossibility,2); } static void justbreaks( word *head, word *tail, int L, int last, errmsg_t errmsg ) /* Chooses line breaks in a list of words according to the */ /* policy in "par.doc" for = 1 (L is and last is */ /* ). head must point to a dummy word, and tail must */ /* point to the last word, whose next field must be NULL. */ { word *w1, *w2; int numgaps, extra, score, gap, maxgap, numbiggaps; *errmsg = '\0'; if (!head->next) return; /* Determine the minimum possible largest inter-word gap: */ w1 = tail; do { w1->score = L; for (numgaps = 0, extra = L - w1->length, w2 = w1->next; extra >= 0; ++numgaps, extra -= 1 + isshifted(w2) + w2->length, w2 = w2->next) { gap = numgaps ? (extra + numgaps - 1) / numgaps : L; if (w2) score = w2->score; else { score = 0; if (!last) gap = 0; } if (gap > score) score = gap; if (score < w1->score) { w1->nextline = w2; w1->score = score; } if (!w2) break; } w1 = w1->prev; } while (w1 != head); maxgap = head->next->score; if (maxgap >= L) { strcpy(errmsg, "Cannot justify.\n"); return; } /* Minimize the sum of the squares of the numbers */ /* of extra spaces required in each inter-word gap: */ w1 = tail; do { w1->score = -1; for (numgaps = 0, extra = L - w1->length, w2 = w1->next; extra >= 0; ++numgaps, extra -= 1 + isshifted(w2) + w2->length, w2 = w2->next) { gap = numgaps ? (extra + numgaps - 1) / numgaps : L; if (w2) score = w2->score; else { if (!last) { w1->nextline = NULL; w1->score = 0; break; } score = 0; } if (gap <= maxgap && score >= 0) { numbiggaps = extra % numgaps; score += (extra / numgaps) * (extra + numbiggaps) + numbiggaps; /* The above may not look like the sum of the squares of the numbers */ /* of extra spaces required in each inter-word gap, but trust me, it */ /* is. It's easier to prove graphically than algebraicly. */ if (w1->score < 0 || score <= w1->score) { w1->nextline = w2; w1->score = score; } } if (!w2) break; } w1 = w1->prev; } while (w1 != head); if (head->next->score < 0) sprintf(errmsg,impossibility,3); } char **reformat( const char * const *inlines, const char * const *endline, int afp, int fs, int hang, int prefix, int suffix, int width, int cap, int fit, int guess, int just, int last, int Report, int touch, const charset *terminalchars, errmsg_t errmsg ) { int numin, affix, L, onfirstword = 1, linelen, numout, numgaps, extra, phase; const char * const *line, **suffixes = NULL, **suf, *end, *p1, *p2; char *q1, *q2, **outlines = NULL; word dummy, *head, *tail, *w1, *w2; buffer *pbuf = NULL; /* Initialization: */ *errmsg = '\0'; dummy.next = dummy.prev = NULL; dummy.flags = 0; head = tail = &dummy; numin = endline - inlines; if (numin <= 0) { sprintf(errmsg,impossibility,4); goto rfcleanup; } numgaps = extra = 0; /* unnecessary, but quiets compiler warnings */ /* Allocate space for pointers to the suffixes: */ suffixes = malloc(numin * sizeof (const char *)); if (!suffixes) { strcpy(errmsg,outofmem); goto rfcleanup; } /* Set the pointers to the suffixes, and create the words: */ affix = prefix + suffix; L = width - prefix - suffix; line = inlines, suf = suffixes; do { for (end = *line; *end; ++end); if (end - *line < affix) { sprintf(errmsg, "Line %ld shorter than + = %d + %d = %d\n", (long)(line - inlines + 1), prefix, suffix, affix); goto rfcleanup; } end -= suffix; *suf = end; p1 = *line + prefix; for (;;) { while (p1 < end && *p1 == ' ') ++p1; if (p1 == end) break; p2 = p1; if (onfirstword) { p1 = *line + prefix; onfirstword = 0; } while (p2 < end && *p2 != ' ') ++p2; w1 = malloc(sizeof (word)); if (!w1) { strcpy(errmsg,outofmem); goto rfcleanup; } w1->next = NULL; w1->prev = tail; tail = tail->next = w1; w1->chrs = p1; w1->length = p2 - p1; w1->flags = 0; p1 = p2; } ++line, ++suf; } while (line < endline); /* If guess is 1, set flag values and merge words: */ if (guess) { for (w1 = head, w2 = head->next; w2; w1 = w2, w2 = w2->next) { if (checkcurious(w2,terminalchars)) w2->flags |= W_CURIOUS; if (cap || checkcapital(w2)) { w2->flags |= W_CAPITAL; if (iscurious(w1)) { if (w1->chrs[w1->length] && w1->chrs + w1->length + 1 == w2->chrs) { w2->length += w1->length + 1; w2->chrs = w1->chrs; w2->prev = w1->prev; w2->prev->next = w2; if (iscapital(w1)) w2->flags |= W_CAPITAL; else w2->flags &= ~W_CAPITAL; if (isshifted(w1)) w2->flags |= W_SHIFTED; else w2->flags &= ~W_SHIFTED; free(w1); } else w2->flags |= W_SHIFTED; } } } tail = w1; } /* Check for too-long words: */ if (Report) for (w2 = head->next; w2; w2 = w2->next) { if (w2->length > L) { linelen = w2->length; if (linelen > errmsg_size - 17) linelen = errmsg_size - 17; sprintf(errmsg, "Word too long: %.*s\n", linelen, w2->chrs); goto rfcleanup; } } else for (w2 = head->next; w2; w2 = w2->next) while (w2->length > L) { w1 = malloc(sizeof (word)); if (!w1) { strcpy(errmsg,outofmem); goto rfcleanup; } w1->next = w2; w1->prev = w2->prev; w1->prev->next = w1; w2->prev = w1; w1->chrs = w2->chrs; w2->chrs += L; w1->length = L; w2->length -= L; w1->flags = 0; if (iscapital(w2)) { w1->flags |= W_CAPITAL; w2->flags &= ~W_CAPITAL; } if (isshifted(w2)) { w1->flags |= W_SHIFTED; w2->flags &= ~W_SHIFTED; } } /* Choose line breaks according to policy in "par.doc": */ if (just) justbreaks(head,tail,L,last,errmsg); else normalbreaks(head,tail,L,fit,last,errmsg); if (*errmsg) goto rfcleanup; /* Change L to the length of the longest line if required: */ if (!just && touch) { L = 0; w1 = head->next; while (w1) { for (linelen = w1->length, w2 = w1->next; w2 != w1->nextline; linelen += 1 + isshifted(w2) + w2->length, w2 = w2->next); if (linelen > L) L = linelen; w1 = w2; } } /* Construct the lines: */ pbuf = newbuffer(sizeof (char *), errmsg); if (*errmsg) goto rfcleanup; numout = 0; w1 = head->next; while (numout < hang || w1) { if (w1) for (w2 = w1->next, numgaps = 0, extra = L - w1->length; w2 != w1->nextline; ++numgaps, extra -= 1 + isshifted(w2) + w2->length, w2 = w2->next); linelen = suffix || (just && (w2 || last)) ? L + affix : w1 ? prefix + L - extra : prefix; q1 = malloc((linelen + 1) * sizeof (char)); if (!q1) { strcpy(errmsg,outofmem); goto rfcleanup; } additem(pbuf, &q1, errmsg); if (*errmsg) goto rfcleanup; ++numout; q2 = q1 + prefix; if (numout <= numin) memcpy(q1, inlines[numout - 1], prefix); else if (numin > hang ) memcpy(q1, endline[-1], prefix); else { if (afp > prefix) afp = prefix; memcpy(q1, endline[-1], afp); q1 += afp; while (q1 < q2) *q1++ = ' '; } q1 = q2; if (w1) { phase = numgaps / 2; for (w2 = w1; ; ) { memcpy(q1, w2->chrs, w2->length); q1 += w2->length; w2 = w2->next; if (w2 == w1->nextline) break; *q1++ = ' '; if (just && (w1->nextline || last)) { phase += extra; while (phase >= numgaps) { *q1++ = ' '; phase -= numgaps; } } if (isshifted(w2)) *q1++ = ' '; } } q2 += linelen - affix; while (q1 < q2) *q1++ = ' '; q2 = q1 + suffix; if (numout <= numin) memcpy(q1, suffixes[numout - 1], suffix); else if (numin > hang ) memcpy(q1, suffixes[numin - 1], suffix); else { if (fs > suffix) fs = suffix; memcpy(q1, suffixes[numin - 1], fs); q1 += fs; while(q1 < q2) *q1++ = ' '; } *q2 = '\0'; if (w1) w1 = w1->nextline; } q1 = NULL; additem(pbuf, &q1, errmsg); if (*errmsg) goto rfcleanup; outlines = copyitems(pbuf,errmsg); rfcleanup: if (suffixes) free(suffixes); while (tail != head) { tail = tail->prev; free(tail->next); } if (pbuf) { if (!outlines) for (;;) { outlines = nextitem(pbuf); if (!outlines) break; free(*outlines); } freebuffer(pbuf); } return outlines; } Par-1.53.0/charset.c0000600000175000037200000001777113633242702012220 0ustar amceng/* charset.c last touched in Par 1.53.0 last meaningful change in Par 1.53.0 Copyright 1993, 2001, 2020 Adam M. Costello This is ANSI C code (C89). Because this is ANSI C code, we can't assume that char has only 8 bits. Therefore, we can't use bit vectors to represent sets without the risk of consuming large amounts of memory. Therefore, this code is much more complicated than might be expected. The issues regarding char and unsigned char are relevant to the use of the ctype.h functions, and the interpretation of the _xhh sequence. See the comments near the beginning of par.c. */ #include "charset.h" /* Makes sure we're consistent with the prototypes. */ #include "buffer.h" #include "errmsg.h" #include #include #include #include #include #undef NULL #define NULL ((void *) 0) #ifdef DONTFREE #define free(ptr) #endif typedef unsigned char csflag_t; struct charset { char *inlist; /* Characters in inlist are in the set. */ char *outlist; /* Characters in outlist are not in the set. */ /* inlist and outlist must have no common characters. */ /* inlist and outlist may be NULL, which acts like "". */ csflag_t flags; /* Characters in neither list are in the set if they */ /* belong to any of the classes indicated by flags. */ }; /* The following may be bitwise-OR'd together */ /* to set the flags field of a charset: */ static const csflag_t CS_UCASE = 1, /* Includes all upper case letters. */ CS_LCASE = 2, /* Includes all lower case letters. */ CS_NCASE = 4, /* Includes all neither case letters. */ CS_DIGIT = 8, /* Includes all decimal digits. */ CS_SPACE = 16, /* Includes all space characters. */ CS_NUL = 32; /* Includes the NUL character. */ static int appearsin(char c, const char *str) /* Returns 0 if c is '\0' or str is NULL or c */ /* does not appear in *str. Otherwise returns 1. */ { return c && str && strchr(str,c); } static int hexdigtoint(char c) /* Returns the value represented by the hexadecimal */ /* digit c, or -1 if c is not a hexadecimal digit. */ { const char *p, * const hexdigits = "0123456789ABCDEFabcdef"; int n; if (!c) return -1; p = strchr(hexdigits, *(unsigned char *)&c); if (!p) return -1; n = p - hexdigits; if (n >= 16) n -= 6; return n; /* We can't do things like c - 'A' because we can't */ /* depend on the order of the characters in ANSI C. */ /* Nor can we do things like hexdigtoint[c] because */ /* we don't know how large such an array might be. */ } charset *parsecharset(const char *str, errmsg_t errmsg) { charset *cset = NULL; buffer *cbuf = NULL; const char *p, * const singleescapes = "_sbqQx"; int hex1, hex2; char ch; cset = malloc(sizeof (charset)); if (!cset) { strcpy(errmsg,outofmem); goto pcserror; } cset->inlist = cset->outlist = NULL; cset->flags = 0; cbuf = newbuffer(sizeof (char), errmsg); if (*errmsg) goto pcserror; for (p = str; *p; ++p) if (*p == '_') { ++p; if (appearsin(*p, singleescapes)) { if (*p == '_') ch = '_' ; else if (*p == 's') ch = ' ' ; else if (*p == 'b') ch = '\\'; else if (*p == 'q') ch = '\''; else if (*p == 'Q') ch = '\"'; else /* *p == 'x' */ { hex1 = hexdigtoint(p[1]); hex2 = hexdigtoint(p[2]); if (hex1 < 0 || hex2 < 0) goto pcsbadstr; *(unsigned char *)&ch = 16 * hex1 + hex2; p += 2; } if (!ch) cset->flags |= CS_NUL; else { additem(cbuf, &ch, errmsg); if (*errmsg) goto pcserror; } } else { if (*p == 'A') cset->flags |= CS_UCASE; else if (*p == 'a') cset->flags |= CS_LCASE; else if (*p == '@') cset->flags |= CS_NCASE; else if (*p == '0') cset->flags |= CS_DIGIT; else if (*p == 'S') cset->flags |= CS_SPACE; else goto pcsbadstr; } } else { additem(cbuf,p,errmsg); if (*errmsg) goto pcserror; } ch = '\0'; additem(cbuf, &ch, errmsg); if (*errmsg) goto pcserror; cset->inlist = copyitems(cbuf,errmsg); if (*errmsg) goto pcserror; pcscleanup: if (cbuf) freebuffer(cbuf); return cset; pcsbadstr: sprintf(errmsg, "Bad charset syntax: %.*s\n", errmsg_size - 22, str); pcserror: if (cset) freecharset(cset); cset = NULL; goto pcscleanup; } void freecharset(charset *cset) { if (cset->inlist) free(cset->inlist); if (cset->outlist) free(cset->outlist); free(cset); } int csmember(char c, const charset *cset) { unsigned char uc; if (appearsin(c, cset->inlist )) return 1; if (appearsin(c, cset->outlist)) return 0; uc = *(unsigned char *)&c; /* The logic for the CS_?CASE flags is a little convoluted, */ /* but avoids calling islower() or isupper() more than once. */ if (cset->flags & CS_NCASE) { if ( isalpha(uc) && (cset->flags & CS_LCASE || !islower(uc)) && (cset->flags & CS_UCASE || !isupper(uc)) ) return 1; } else { if ( (cset->flags & CS_LCASE && islower(uc)) || (cset->flags & CS_UCASE && isupper(uc)) ) return 1; } return (cset->flags & CS_DIGIT && isdigit(uc)) || (cset->flags & CS_SPACE && isspace(uc)) || (cset->flags & CS_NUL && !c ) ; } static charset *csud( int u, const charset *cset1, const charset *cset2, errmsg_t errmsg ) /* Returns the union of cset1 and cset2 if u is 1, or the set */ /* difference cset1 - cset2 if u is 0. Returns NULL on failure. */ { charset *csu; buffer *inbuf = NULL, *outbuf = NULL; char *lists[4], **list, *p, nullchar = '\0'; csu = malloc(sizeof (charset)); if (!csu) { strcpy(errmsg,outofmem); goto csuderror; } inbuf = newbuffer(sizeof (char), errmsg); if (*errmsg) goto csuderror; outbuf = newbuffer(sizeof (char), errmsg); if (*errmsg) goto csuderror; csu->inlist = csu->outlist = NULL; csu->flags = u ? cset1->flags | cset2->flags : cset1->flags & ~cset2->flags; lists[0] = cset1->inlist; lists[1] = cset1->outlist; lists[2] = cset2->inlist; lists[3] = cset2->outlist; for (list = lists; list < lists + 4; ++list) if (*list) { for (p = *list; *p; ++p) if (u ? csmember(*p, cset1) || csmember(*p, cset2) : csmember(*p, cset1) && !csmember(*p, cset2)) { if (!csmember(*p, csu)) { additem(inbuf,p,errmsg); if (*errmsg) goto csuderror; } } else if (csmember(*p, csu)) { additem(outbuf,p,errmsg); if (*errmsg) goto csuderror; } } additem(inbuf, &nullchar, errmsg); if (*errmsg) goto csuderror; additem(outbuf, &nullchar, errmsg); if (*errmsg) goto csuderror; csu->inlist = copyitems(inbuf,errmsg); if (*errmsg) goto csuderror; csu->outlist = copyitems(outbuf,errmsg); if (*errmsg) goto csuderror; csudcleanup: if (inbuf) freebuffer(inbuf); if (outbuf) freebuffer(outbuf); return csu; csuderror: if (csu) freecharset(csu); csu = NULL; goto csudcleanup; } charset *csunion(const charset *cset1, const charset *cset2, errmsg_t errmsg) { return csud(1,cset1,cset2,errmsg); } charset *csdiff(const charset *cset1, const charset *cset2, errmsg_t errmsg) { return csud(0,cset1,cset2,errmsg); } void csadd(charset *cset1, const charset *cset2, errmsg_t errmsg) { charset *csu; csu = csunion(cset1,cset2,errmsg); if (*errmsg) return; csswap(csu,cset1); freecharset(csu); } void csremove(charset *cset1, const charset *cset2, errmsg_t errmsg) { charset *csu; csu = csdiff(cset1,cset2,errmsg); if (*errmsg) return; csswap(csu,cset1); freecharset(csu); } charset *cscopy(const charset *cset, errmsg_t errmsg) { charset emptycharset = { NULL, NULL, 0 }; return csunion(cset, &emptycharset, errmsg); } void csswap(charset *cset1, charset *cset2) { charset tmp; tmp = *cset1; *cset1 = *cset2; *cset2 = tmp; } Par-1.53.0/protoMakefile0000600000175000037200000000550313633243044013135 0ustar amceng# protoMakefile # last touched in Par 1.53.0 # last meaningful change in Par 1.53.0 # Copyright 1993, 1996, 2020 Adam M. Costello ##### ##### Instructions ##### # If you have no make command (or equivalent), you can easily tell by # looking at this file what make would do. It would compile each .c # file into a .o file, then link all the .o files into the executable # par. You can do this manually. Then you should go look for a version # of make for your system, since it will come in handy in the future. # If you do have make, you can either copy this file to Makefile, edit # the definitions of CC, LINK1, LINK2, RM, JUNK, O, and E, and then run # make; or, better yet, create a short script which looks something # like: # # #!/bin/sh # make -f protoMakefile CC="cc -c" LINK1="cc" LINK2="-o" RM="rm" JUNK="" $* # # (Alter this to use commands and values appropriate for your compiler # and shell). The advantage of the second method is that the script # will probably work on the next release of Par. ##### ##### Configuration ##### # Define CC so that the command # # $(CC) foo.c # # compiles the ANSI C source file "foo.c" into the object file "foo.o". # You may assume that foo.c uses no floating point math. # # If your operating system or your compiler's exit() function # automatically frees all memory allocated by malloc() when a process # terminates, then you can choose to trade away space efficiency for # time efficiency by defining DONTFREE. # # Example (for Solaris 2.x with SPARCompiler C): # CC = cc -c -O -s -Xc -DDONTFREE CPPFLAGS = CFLAGS = CC = cc $(CPPFLAGS) $(CFLAGS) -c # Define LINK1 and LINK2 so that the command # # $(LINK1) foo1.o foo2.o foo3.o $(LINK2) foo # # links the object files "foo1.o", "foo2.o", "foo3.o" into the # executable file "foo". You may assume that none of the .o files use # floating point math. # # Example (for Solaris 2.x with SPARCompiler C): # LINK1 = cc -s # LINK2 = -o LINK1 = cc LINK2 = -o # Define RM so that the command # # $(RM) foo1 foo2 foo3 # # removes the files "foo1", "foo2", and "foo3", and preferably doesn't # complain if they don't exist. RM = rm -f # Define JUNK to be a list of additional files, other than par and # $(OBJS), that you want to be removed by "make clean". JUNK = # Define O to be the usual suffix for object files. O = .o # Define E to be the usual suffix for executable files. E = ##### ##### Guts (you shouldn't need to touch this part) ##### OBJS = buffer$O charset$O errmsg$O par$O reformat$O .c$O: $(CC) $< par$E: $(OBJS) $(LINK1) $(OBJS) $(LINK2) par$E buffer$O: buffer.c buffer.h errmsg.h charset$O: charset.c charset.h errmsg.h buffer.h errmsg$O: errmsg.c errmsg.h par$O: par.c charset.h errmsg.h buffer.h reformat.h reformat$O: reformat.c reformat.h buffer.h charset.h errmsg.h test: par$E ./test-par ./par$E clean: $(RM) par$E $(OBJS) $(JUNK) Par-1.53.0/buffer.h0000600000175000037200000000430213633131200012015 0ustar amceng/* buffer.h last touched in Par 1.53.0 last meaningful change in Par 1.31 Copyright 1993 Adam M. Costello This is ANSI C code (C89). Note: Those functions declared here which do not use errmsg always succeed, provided that they are passed valid arguments. */ #include "errmsg.h" #include typedef struct buffer buffer; buffer *newbuffer(size_t itemsize, errmsg_t errmsg); /* newbuffer(itemsize,errmsg) returns a pointer to a */ /* new empty buffer which holds items of size itemsize. */ /* itemsize must not be 0. Returns NULL on failure. */ void freebuffer(buffer *buf); /* freebuffer(buf) frees the memory associated with */ /* *buf. buf may not be used after this call. */ void clearbuffer(buffer *buf); /* clearbuffer(buf) removes */ /* all items from *buf, but */ /* does not free any memory. */ void additem(buffer *buf, const void *item, errmsg_t errmsg); /* additem(buf,item,errmsg) copies *item to the end of */ /* *buf. item must point to an object of the proper size */ /* for *buf. If additem() fails, *buf will be unaffected. */ int numitems(buffer *buf); /* numitems(buf) returns the number of items in *buf. */ void *copyitems(buffer *buf, errmsg_t errmsg); /* copyitems(buf,errmsg) returns an array of objects of */ /* the proper size for *buf, one for each item in *buf, */ /* or NULL if there are no items in buf. The elements */ /* of the array are copied from the items in *buf, in */ /* order. The array is allocated with malloc(), so it */ /* may be freed with free(). Returns NULL on failure. */ void *nextitem(buffer *buf); /* When buf was created by newbuffer, a pointer associated with buf */ /* was initialized to point at the first slot in *buf. If there is */ /* an item in the slot currently pointed at, nextitem(buf) advances */ /* the pointer to the next slot and returns the old value. If there */ /* is no item in the slot, nextitem(buf) leaves the pointer where it */ /* is and returns NULL. */ void rewindbuffer(buffer *buf); /* rewindbuffer(buf) resets the pointer used by */ /* nextitem() to point at the first slot in *buf. */ Par-1.53.0/errmsg.h0000600000175000037200000000165713633127573012077 0ustar amceng/* errmsg.h last touched in Par 1.53.0 last meaningful change in Par 1.40 Copyright 1993 Adam M. Costello This is ANSI C code (C89). */ #ifndef ERRMSG_H #define ERRMSG_H #define errmsg_size 163 /* This is the maximum number of characters that will */ /* fit in an errmsg_t, including the terminating '\0'. */ /* It will never decrease, but may increase in future */ /* versions of this header file. */ typedef char errmsg_t[errmsg_size]; /* Any function which takes the argument errmsg_t errmsg must, before */ /* returning, either set errmsg[0] to '\0' (indicating success), or */ /* write an error message string into errmsg, (indicating failure), */ /* being careful not to overrun the space. */ extern const char * const outofmem; /* "Out of memory.\n" */ extern const char * const impossibility; /* "Impossibility #%d has occurred. Please report it.\n" */ #endif Par-1.53.0/par.c0000600000175000037200000006703513633277117011357 0ustar amceng/* par.c last touched in Par 1.53.0 last meaningful change in Par 1.53.0 Copyright 1993, 1996, 2001, 2020 Adam M. Costello This is ANSI C code (C89). */ #include "buffer.h" #include "charset.h" #include "errmsg.h" #include "reformat.h" #include #include #include #include #include #include #undef NULL #define NULL ((void *) 0) #ifdef DONTFREE #define free(ptr) #endif /*=== Regarding char and unsigned char: ANSI C is a nightmare in this respect. Some functions, like puts(), strchr(), and getenv(), use char or char*, so they work well with character constants like 'a', which are char, and with argv, which is char**. But several other functions, like getchar(), putchar(), and isdigit(), use unsigned char (converted to/from int). Therefore innocent-looking code can be wrong, for example: int c = getchar(); if (c == 'a') ... This is wrong because 'a' is char (converted to int) and could be negative, but getchar() returns unsigned char (converted to int), so c is always nonnegative or EOF. For similar reasons, it is wrong to pass a char to a function that expects an unsigned char: putchar('\n'); if (isdigit(argv[1][0])) ... Inevitably, we need to convert between char and unsigned char. This can be done by integral conversion (casting or assigning a char to unsigned char or vice versa), or by aliasing (converting a pointer to char to a pointer to unsigned char (or vice versa) and then dereferencing it). ANSI C requires that integral conversion alters the bits when the unsigned value is not representable in the signed type and the signed type does not use two's complement representation. Aliasing, on the other hand, preserves the bits. Although the C standard is not at all clear about which sort of conversion is appropriate for making the standard library functions interoperate, I think preserving the bits is what is needed. Under that assumption, here are some examples of correct code: int c = getchar(); char ch; if (c != EOF) { *(unsigned char *)&ch = c; if (ch == 'a') ... if (isdigit(c)) ... } char *s = ... if (isdigit(*(unsigned char *)s)) ... ===*/ static const char * const usagemsg = "\n" "Options for par:\n" "\n" "help print option summary " " ---------- Boolean parameters: ---------\n" "version print version number " " b let non-trailing body chars in\n" "B as is =/+/-, " " prefix, non-leading in suffix\n" " replace/augment/diminish " " c count all words as capitalized\n" " body chars by " " d
use indentation as a delimiter\n" "P,Q,W,Z ditto for protective, " " E send messages to stderr\n" " quote,white,terminal chars" " e discard superfluous lines\n" "-------- Integer parameters: --------" " f narrow paragraph for best fit\n" "h skip IP's 1st lines" " g preserve wide sentence breaks\n" " in scan for common affixes" " i hide lines inserted by \n" "p prefix length " " j justify paragraphs\n" "r if not 0, force bodiless " " l treat last lines like others\n" " lines to length " " q supply vacant lines between\n" "s suffix length " " different quote nesting levels\n" "T tab stops every cols" " R print error for too-long words\n" "w max output line length " " t move suffixes left\n" "\n" "See par.doc or par.1 (the man page) for more information.\n" "\n" ; /* Structure for recording properties of lines within segments: */ typedef unsigned char lflag_t; typedef struct lineprop { short p, s; /* Length of the prefix and suffix of a bodiless */ /* line, or the fallback prelen and suflen */ /* of the IP containing a non-bodiless line. */ lflag_t flags; /* Boolean properties (see below). */ char rc; /* The repeated character of a bodiless line. */ } lineprop; /* Flags for marking boolean properties: */ static const lflag_t L_BODILESS = 1, /* Bodiless line. */ L_INSERTED = 2, /* Inserted by quote. */ L_FIRST = 4, /* First line of a paragraph. */ L_SUPERF = 8; /* Superfluous line. */ #define isbodiless(prop) ( (prop)->flags & 1) #define isinserted(prop) (((prop)->flags & 2) != 0) #define isfirst(prop) (((prop)->flags & 4) != 0) #define issuperf(prop) (((prop)->flags & 8) != 0) #define isvacant(prop) (isbodiless(prop) && (prop)->rc == ' ') static int digtoint(char c) /* Returns the value represented by the digit c, or -1 if c is not a digit. */ { const char *p, * const digits = "0123456789"; if (!c) return -1; p = strchr(digits,c); return p ? p - digits : -1; /* We can't simply return c - '0' because this is ANSI C code, */ /* so it has to work for any character set, not just ones which */ /* put the digits together in order. Also, an array that could */ /* be referenced as digtoint[c] might be bad because there's no */ /* upper limit on CHAR_MAX. */ } static int strtoudec(const char *s, int *pn) /* Converts the longest prefix of string s consisting of decimal */ /* digits to an integer, which is stored in *pn. Normally returns */ /* 1. If *s is not a digit, then *pn is not changed, but 1 is */ /* still returned. If the integer represented is greater than */ /* 9999, then *pn is not changed and 0 is returned. */ { int n = 0, d; d = digtoint(*s); if (d < 0) return 1; do { if (n >= 1000) return 0; n = 10 * n + d; d = digtoint(*++s); } while (d >= 0); *pn = n; return 1; } static void parsearg( const char *arg, int *phelp, int *pversion, charset *bodychars, charset *protectchars, charset *quotechars, charset *whitechars, charset *terminalchars, int *phang, int *pprefix, int *prepeat, int *psuffix, int *pTab, int *pwidth, int *pbody, int *pcap, int *pdiv, int *pErr, int *pexpel, int *pfit, int *pguess, int *pinvis, int *pjust, int *plast, int *pquote, int *pReport, int *ptouch, errmsg_t errmsg ) /* Parses the command line argument in *arg, setting the objects pointed to */ /* by the other pointers as appropriate. *phelp and *pversion are boolean */ /* flags indicating whether the help and version options were supplied. */ { const char *savearg = arg; charset *chars, *change; char oc; int n; *errmsg = '\0'; if (*arg == '-') ++arg; if (!strcmp(arg, "help")) { *phelp = 1; return; } if (!strcmp(arg, "version")) { *pversion = 1; return; } chars = *arg == 'B' ? bodychars : *arg == 'P' ? protectchars : *arg == 'Q' ? quotechars : *arg == 'W' ? whitechars : *arg == 'Z' ? terminalchars : NULL; if (chars) { ++arg; if (*arg != '=' && *arg != '+' && *arg != '-') goto badarg; change = parsecharset(arg + 1, errmsg); if (change) { if (*arg == '=') csswap(chars,change); else if (*arg == '+') csadd(chars,change,errmsg); else /* *arg == '-' */ csremove(chars,change,errmsg); freecharset(change); } return; } if (isdigit(*(unsigned char *)arg)) { if (!strtoudec(arg, &n)) goto badarg; if (n <= 8) *pprefix = n; else *pwidth = n; } for (;;) { while (isdigit(*(unsigned char *)arg)) ++arg; oc = *arg; if (!oc) break; n = -1; if (!strtoudec(++arg, &n)) goto badarg; if ( oc == 'h' || oc == 'p' || oc == 'r' || oc == 's' || oc == 'T' || oc == 'w') { if (oc == 'h') *phang = n >= 0 ? n : 1; else if (oc == 'p') *pprefix = n; else if (oc == 'r') *prepeat = n >= 0 ? n : 3; else if (oc == 's') *psuffix = n; else if (oc == 'T') *pTab = n >= 0 ? n : 8; else /* oc == 'w' */ *pwidth = n >= 0 ? n : 79; } else { if (n < 0) n = 1; if (n > 1) goto badarg; if (oc == 'b') *pbody = n; else if (oc == 'c') *pcap = n; else if (oc == 'd') *pdiv = n; else if (oc == 'E') *pErr = n; else if (oc == 'e') *pexpel = n; else if (oc == 'f') *pfit = n; else if (oc == 'g') *pguess = n; else if (oc == 'i') *pinvis = n; else if (oc == 'j') *pjust = n; else if (oc == 'l') *plast = n; else if (oc == 'q') *pquote = n; else if (oc == 'R') *pReport = n; else if (oc == 't') *ptouch = n; else goto badarg; } } return; badarg: sprintf(errmsg, "Bad argument: %.*s\n", errmsg_size - 16, savearg); *phelp = 1; } static char **readlines( lineprop **pprops, const charset *protectchars, const charset *quotechars, const charset *whitechars, int Tab, int invis, int quote, errmsg_t errmsg ) /* Reads lines from stdin until EOF, or until a line beginning with a */ /* protective character is encountered (in which case the protective */ /* character is pushed back onto the input stream), or until a blank */ /* line is encountered (in which case the newline is pushed back onto */ /* the input stream). Returns a NULL-terminated array of pointers to */ /* individual lines, stripped of their newline characters. Every NUL */ /* character is stripped, and every white character is changed to a */ /* space unless it is a newline. If quote is 1, vacant lines will be */ /* supplied as described for the q option in par.doc. *pprops is set */ /* to an array of lineprop structures, one for each line, each of whose */ /* flags field is either 0 or L_INSERTED (the other fields are 0). If */ /* there are no lines, *pprops is set to NULL. The returned array may */ /* be freed with freelines(). *pprops may be freed with free() if */ /* it's not NULL. On failure, returns NULL and sets *pprops to NULL. */ { buffer *cbuf = NULL, *lbuf = NULL, *lpbuf = NULL; int c, empty, blank, firstline, qsonly, oldqsonly = 0, vlnlen, i; char ch, *ln = NULL, nullchar = '\0', *nullline = NULL, *qpend, *oldln = NULL, *oldqpend = NULL, *p, *op, *vln = NULL, **lines = NULL; lineprop vprop = { 0, 0, 0, '\0' }, iprop = { 0, 0, 0, '\0' }; /* oldqsonly, oldln, and oldquend don't really need to be initialized. */ /* They are initialized only to appease compilers that try to be helpful */ /* by issuing warnings about unitialized automatic variables. */ iprop.flags = L_INSERTED; *errmsg = '\0'; *pprops = NULL; cbuf = newbuffer(sizeof (char), errmsg); if (*errmsg) goto rlcleanup; lbuf = newbuffer(sizeof (char *), errmsg); if (*errmsg) goto rlcleanup; lpbuf = newbuffer(sizeof (lineprop), errmsg); if (*errmsg) goto rlcleanup; for (empty = blank = firstline = 1; ; ) { c = getchar(); if (c == EOF) break; *(unsigned char *)&ch = c; if (ch == '\n') { if (blank) { ungetc(c,stdin); break; } additem(cbuf, &nullchar, errmsg); if (*errmsg) goto rlcleanup; ln = copyitems(cbuf,errmsg); if (*errmsg) goto rlcleanup; if (quote) { for (qpend = ln; *qpend && csmember(*qpend, quotechars); ++qpend); for (p = qpend; *p == ' ' || csmember(*p, quotechars); ++p); qsonly = *p == '\0'; while (qpend > ln && qpend[-1] == ' ') --qpend; if (!firstline) { for (p = ln, op = oldln; p < qpend && op < oldqpend && *p == *op; ++p, ++op); if (!(p == qpend && op == oldqpend)) { if (!invis && (oldqsonly || qsonly)) { if (oldqsonly) { *op = '\0'; oldqpend = op; } if (qsonly) { *p = '\0'; qpend = p; } } else { vlnlen = p - ln; vln = malloc((vlnlen + 1) * sizeof (char)); if (!vln) { strcpy(errmsg,outofmem); goto rlcleanup; } strncpy(vln,ln,vlnlen); vln[vlnlen] = '\0'; additem(lbuf, &vln, errmsg); if (*errmsg) goto rlcleanup; additem(lpbuf, &iprop, errmsg); if (*errmsg) goto rlcleanup; vln = NULL; } } } oldln = ln; oldqpend = qpend; oldqsonly = qsonly; } additem(lbuf, &ln, errmsg); if (*errmsg) goto rlcleanup; ln = NULL; additem(lpbuf, &vprop, errmsg); if (*errmsg) goto rlcleanup; clearbuffer(cbuf); empty = blank = 1; firstline = 0; } else { if (empty) { if (csmember(ch, protectchars)) { ungetc(c,stdin); break; } empty = 0; } if (!ch) continue; if (ch == '\t') { ch = ' '; for (i = Tab - numitems(cbuf) % Tab; i > 0; --i) { additem(cbuf, &ch, errmsg); if (*errmsg) goto rlcleanup; } continue; } if (csmember(ch, whitechars)) ch = ' '; else blank = 0; additem(cbuf, &ch, errmsg); if (*errmsg) goto rlcleanup; } } if (!blank) { additem(cbuf, &nullchar, errmsg); if (*errmsg) goto rlcleanup; ln = copyitems(cbuf,errmsg); if (*errmsg) goto rlcleanup; additem(lbuf, &ln, errmsg); if (*errmsg) goto rlcleanup; ln = NULL; additem(lpbuf, &vprop, errmsg); if (*errmsg) goto rlcleanup; } additem(lbuf, &nullline, errmsg); if (*errmsg) goto rlcleanup; *pprops = copyitems(lpbuf,errmsg); if (*errmsg) goto rlcleanup; lines = copyitems(lbuf,errmsg); rlcleanup: if (cbuf) freebuffer(cbuf); if (lpbuf) freebuffer(lpbuf); if (lbuf) { if (!lines) for (;;) { lines = nextitem(lbuf); if (!lines) break; free(*lines); } freebuffer(lbuf); } if (ln) free(ln); if (vln) free(vln); return lines; } static void compresuflen( const char * const *lines, const char * const *endline, const charset *bodychars, int body, int pre, int suf, int *ppre, int *psuf ) /* lines is an array of strings, up to but not including endline. */ /* Writes into *ppre and *psuf the comprelen and comsuflen of the */ /* lines in lines. Assumes that they have already been determined */ /* to be at least pre and suf. endline must not equal lines. */ { const char *start, *end, *knownstart, * const *line, *p1, *p2, *knownend, *knownstart2; start = *lines; end = knownstart = start + pre; if (body) while (*end) ++end; else while (*end && !csmember(*end, bodychars)) ++end; for (line = lines + 1; line < endline; ++line) { for (p1 = knownstart, p2 = *line + pre; p1 < end && *p1 == *p2; ++p1, ++p2); end = p1; } if (body) for (p1 = end; p1 > knownstart; ) if (*--p1 != ' ') { if (csmember(*p1, bodychars)) end = p1; else break; } *ppre = end - start; knownstart = *lines + *ppre; for (end = knownstart; *end; ++end); knownend = end - suf; if (body) start = knownstart; else for (start = knownend; start > knownstart && !csmember(start[-1], bodychars); --start); for (line = lines + 1; line < endline; ++line) { knownstart2 = *line + *ppre; for (p2 = knownstart2; *p2; ++p2); for (p1 = knownend, p2 -= suf; p1 > start && p2 > knownstart2 && p1[-1] == p2[-1]; --p1, --p2); start = p1; } if (body) { for (p1 = start; start < knownend && (*start == ' ' || csmember(*start, bodychars)); ++start); if (start > p1 && start[-1] == ' ') --start; } else while (end - start >= 2 && *start == ' ' && start[1] == ' ') ++start; *psuf = end - start; } static void delimit( const char * const *lines, const char * const *endline, const charset *bodychars, int repeat, int body, int div, int pre, int suf, lineprop *props ) /* lines is an array of strings, up to but not including */ /* endline. Sets fields in each lineprop in the parallel */ /* array props as appropriate, except for the L_SUPERF flag, */ /* which is never set. It is assumed that the comprelen */ /* and comsuflen of the lines in lines have already been */ /* determined to be at least pre and suf, respectively. */ { const char * const *line, *end, *p, * const *nextline; char rc; lineprop *prop, *nextprop; int anybodiless = 0, status; if (endline == lines) return; if (endline == lines + 1) { props->flags |= L_FIRST; props->p = pre, props->s = suf; return; } compresuflen(lines, endline, bodychars, body, pre, suf, &pre, &suf); line = lines, prop = props; do { prop->flags |= L_BODILESS; prop->p = pre, prop->s = suf; for (end = *line; *end; ++end); end -= suf; p = *line + pre; rc = p < end ? *p : ' '; if (rc != ' ' && (isinserted(prop) || !repeat || end - p < repeat)) prop->flags &= ~L_BODILESS; else while (p < end) { if (*p != rc) { prop->flags &= ~L_BODILESS; break; } ++p; } if (isbodiless(prop)) { anybodiless = 1; prop->rc = rc; } ++line, ++prop; } while (line < endline); if (anybodiless) { line = lines, prop = props; do { if (isbodiless(prop)) { ++line, ++prop; continue; } for (nextline = line + 1, nextprop = prop + 1; nextline < endline && !isbodiless(nextprop); ++nextline, ++nextprop); delimit(line,nextline,bodychars,repeat,body,div,pre,suf,prop); line = nextline, prop = nextprop; } while (line < endline); return; } if (!div) { props->flags |= L_FIRST; return; } line = lines, prop = props; status = ((*lines)[pre] == ' '); do { if (((*line)[pre] == ' ') == status) prop->flags |= L_FIRST; ++line, ++prop; } while (line < endline); } static void marksuperf( const char * const * lines, const char * const * endline, lineprop *props ) /* lines points to the first line of a segment, and endline to one */ /* line beyond the last line in the segment. Sets L_SUPERF bits in */ /* the flags fields of the props array whenever the corresponding */ /* line is superfluous. L_BODILESS bits must already be set. */ { const char * const *line, *p; lineprop *prop, *mprop, dummy; int inbody, num, mnum; for (line = lines, prop = props; line < endline; ++line, ++prop) if (isvacant(prop)) prop->flags |= L_SUPERF; inbody = mnum = 0; mprop = &dummy; for (line = lines, prop = props; line < endline; ++line, ++prop) if (isvacant(prop)) { for (num = 0, p = *line; *p; ++p) if (*p != ' ') ++num; if (inbody || num < mnum) mnum = num, mprop = prop; inbody = 0; } else { if (!inbody) mprop->flags &= ~L_SUPERF; inbody = 1; } } static void setaffixes( const char * const *inlines, const char * const *endline, const lineprop *props, const charset *bodychars, const charset *quotechars, int hang, int body, int quote, int *pafp, int *pfs, int *pprefix, int *psuffix ) /* inlines is an array of strings, up to but not including endline, */ /* representing an IP. inlines and endline must not be equal. props */ /* is the the parallel array of lineprop structures. *pafp and *pfs */ /* are set to the augmented fallback prelen and fallback suflen of the */ /* IP. If either of *pprefix, *psuffix is less than 0, it is set to a */ /* default value as specified in "par.doc". */ { int numin, pre, suf; const char *p; numin = endline - inlines; if ((*pprefix < 0 || *psuffix < 0) && numin > hang + 1) compresuflen(inlines + hang, endline, bodychars, body, 0, 0, &pre, &suf); p = *inlines + props->p; if (numin == 1 && quote) while (*p && csmember (*p, quotechars)) ++p; *pafp = p - *inlines; *pfs = props->s; if (*pprefix < 0) *pprefix = numin > hang + 1 ? pre : *pafp; if (*psuffix < 0) *psuffix = numin > hang + 1 ? suf : *pfs; } static void freelines(char **lines) /* Frees the elements of lines, and lines itself. */ /* lines is a NULL-terminated array of strings. */ { char **line; for (line = lines; *line; ++line) free(*line); free(lines); } int main(int argc, const char * const *argv) { int help = 0, version = 0, hang = 0, prefix = -1, repeat = 0, suffix = -1, Tab = 1, width = 72, body = 0, cap = 0, div = 0, Err = 0, expel = 0, fit = 0, guess = 0, invis = 0, just = 0, last = 0, quote = 0, Report = 0, touch = -1; int prefixbak, suffixbak, c, sawnonblank, oweblank, n, i, afp, fs; charset *bodychars = NULL, *protectchars = NULL, *quotechars = NULL, *whitechars = NULL, *terminalchars = NULL; char *parinit = NULL, *arg, **inlines = NULL, **endline, **firstline, *end, **nextline, **outlines = NULL, **line, ch; const char *env, * const init_whitechars = " \f\n\r\t\v"; errmsg_t errmsg = { '\0' }; lineprop *props = NULL, *firstprop, *nextprop; FILE *errout; /* Set the current locale from the environment: */ setlocale(LC_ALL,""); /* Process environment variables: */ env = getenv("PARBODY"); if (!env) env = ""; bodychars = parsecharset(env,errmsg); if (*errmsg) { help = 1; goto parcleanup; } env = getenv("PARPROTECT"); if (!env) env = ""; protectchars = parsecharset(env,errmsg); if (*errmsg) { help = 1; goto parcleanup; } env = getenv("PARQUOTE"); if (!env) env = "> "; quotechars = parsecharset(env,errmsg); if (*errmsg) { help = 1; goto parcleanup; } whitechars = parsecharset(init_whitechars, errmsg); if (*errmsg) goto parcleanup; terminalchars = parsecharset(".?!:", errmsg); if (*errmsg) goto parcleanup; env = getenv("PARINIT"); if (env) { parinit = malloc((strlen(env) + 1) * sizeof (char)); if (!parinit) { strcpy(errmsg,outofmem); goto parcleanup; } strcpy(parinit,env); arg = strtok(parinit, init_whitechars); while (arg) { parsearg(arg, &help, &version, bodychars, protectchars, quotechars, whitechars, terminalchars, &hang, &prefix, &repeat, &suffix, &Tab, &width, &body, &cap, &div, &Err, &expel, &fit, &guess, &invis, &just, &last, "e, &Report, &touch, errmsg ); if (*errmsg || help || version) goto parcleanup; arg = strtok(NULL, init_whitechars); } free(parinit); parinit = NULL; } /* Process command line arguments: */ while (*++argv) { parsearg(*argv, &help, &version, bodychars, protectchars, quotechars, whitechars, terminalchars, &hang, &prefix, &repeat, &suffix, &Tab, &width, &body, &cap, &div, &Err, &expel, &fit, &guess, &invis, &just, &last, "e, &Report, &touch, errmsg ); if (*errmsg || help || version) goto parcleanup; } if (Tab == 0) { strcpy(errmsg, " must not be 0.\n"); goto parcleanup; } if (touch < 0) touch = fit || last; prefixbak = prefix; suffixbak = suffix; /* Main loop: */ for (sawnonblank = oweblank = 0; ; ) { for (;;) { c = getchar(); if (c == EOF) break; *(unsigned char *)&ch = c; if (expel && ch == '\n') { oweblank = sawnonblank; continue; } if (csmember(ch, protectchars)) { sawnonblank = 1; if (oweblank) { puts(""); oweblank = 0; } while (ch != '\n') { putchar(c); c = getchar(); if (c == EOF) break; *(unsigned char *)&ch = c; } } if (ch != '\n') break; /* subsumes the case that c == EOF */ putchar(c); } if (c == EOF) break; ungetc(c,stdin); inlines = readlines(&props, protectchars, quotechars, whitechars, Tab, invis, quote, errmsg); if (*errmsg) goto parcleanup; for (endline = inlines; *endline; ++endline); if (endline == inlines) { free(inlines); inlines = NULL; continue; } sawnonblank = 1; if (oweblank) { puts(""); oweblank = 0; } delimit((const char * const *) inlines, (const char * const *) endline, bodychars, repeat, body, div, 0, 0, props); if (expel) marksuperf((const char * const *) inlines, (const char * const *) endline, props); firstline = inlines, firstprop = props; do { if (isbodiless(firstprop)) { if ( !(invis && isinserted(firstprop)) && !(expel && issuperf(firstprop))) { for (end = *firstline; *end; ++end); if (!repeat || (firstprop->rc == ' ' && !firstprop->s)) { while (end > *firstline && end[-1] == ' ') --end; *end = '\0'; puts(*firstline); } else { n = width - firstprop->p - firstprop->s; if (n < 0) { sprintf(errmsg,impossibility,5); goto parcleanup; } printf("%.*s", firstprop->p, *firstline); for (i = n; i; --i) putchar(*(unsigned char *)&firstprop->rc); puts(end - firstprop->s); } } ++firstline, ++firstprop; continue; } for (nextline = firstline + 1, nextprop = firstprop + 1; nextline < endline && !isbodiless(nextprop) && !isfirst(nextprop); ++nextline, ++nextprop); prefix = prefixbak, suffix = suffixbak; setaffixes((const char * const *) firstline, (const char * const *) nextline, firstprop, bodychars, quotechars, hang, body, quote, &afp, &fs, &prefix, &suffix); if (width <= prefix + suffix) { sprintf(errmsg, " (%d) <= (%d) + (%d)\n", width, prefix, suffix); goto parcleanup; } outlines = reformat((const char * const *) firstline, (const char * const *) nextline, afp, fs, hang, prefix, suffix, width, cap, fit, guess, just, last, Report, touch, (const charset *) terminalchars, errmsg); if (*errmsg) goto parcleanup; for (line = outlines; *line; ++line) puts(*line); freelines(outlines); outlines = NULL; firstline = nextline, firstprop = nextprop; } while (firstline < endline); freelines(inlines); inlines = NULL; free(props); props = NULL; } parcleanup: if (bodychars) freecharset(bodychars); if (protectchars) freecharset(protectchars); if (quotechars) freecharset(quotechars); if (parinit) free(parinit); if (inlines) freelines(inlines); if (props) free(props); if (outlines) freelines(outlines); errout = Err ? stderr : stdout; if (*errmsg) fprintf(errout, "par error:\n%.*s", errmsg_size, errmsg); if (version) fputs("par 1.53.0\n",errout); if (help) fputs(usagemsg,errout); return *errmsg ? EXIT_FAILURE : EXIT_SUCCESS; } Par-1.53.0/reformat.h0000600000175000037200000000222113633277743012410 0ustar amceng/* reformat.h last touched in Par 1.53.0 last meaningful change in Par 1.53.0 Copyright 1993, 2020 Adam M. Costello This is ANSI C code (C89). */ #include "charset.h" #include "errmsg.h" char **reformat( const char * const *inlines, const char * const *endline, int afp, int fs, int hang, int prefix, int suffix, int width, int cap, int fit, int guess, int just, int last, int Report, int touch, const charset *terminalchars, errmsg_t errmsg ); /* inlines is an array of pointers to input lines, up to but not */ /* including endline. inlines and endline must not be equal. */ /* terminalchars is the set of terminal characters as described */ /* in "par.doc". The other parameters are variables described in */ /* "par.doc". reformat(inlines, endline, afp, fs, hang, prefix, */ /* suffix, width, cap, fit, guess, just, last, Report, touch, */ /* terminalchars, errmsg) returns a NULL-terminated array of */ /* pointers to output lines containing the reformatted paragraph, */ /* according to the specification in "par.doc". None of the */ /* integer parameters may be negative. Returns NULL on failure. */ Par-1.53.0/par.doc0000600000175000037200000015643713633277364011713 0ustar amcengpar.doc last touched in Par 1.53.0 last meaningful change in Par 1.53.0 Copyright 1993, 1996, 2000, 2001, 2020 Adam M. Costello Par 1.53.0 is a package containing: + This doc file. + A man page based on this doc file. + The ANSI C source for the filter "par". + Associated scripts and text. Contents Contents File List Rights and Responsibilities Compilation Synopsis Description *Quick Start Terminology Options Environment Details Diagnostics Examples Limitations Apologies Bugs File List Par 1.53.0 consists of the following files: buffer.c 1.53.0 buffer.h 1.53.0 charset.c 1.53.0 charset.h 1.53.0 errmsg.c 1.53.0 errmsg.h 1.53.0 par.1 1.53.0 par.c 1.53.0 par.doc 1.53.0 protoMakefile 1.53.0 reformat.c 1.53.0 reformat.h 1.53.0 releasenotes 1.53.0 test-par 1.53.0 The version number for each file is defined to be the last version of Par that touched it. Each file is a text file which identifies itself on the first or second line, and identifies the version of Par that last touched it on the next line, so you can always tell which file is which, even if the files have been renamed. The file "par.1" is a man page for the filter par (not to be confused with the package Par, which contains the source code for par). "par.1" is based on this doc file, and conveys much (not all) of the same information, but "par.doc" is the definitive documentation for both par and Par. Rights and Responsibilities The files listed in the Files List section above are Copyright (various years, see the copyright notice in each file) Adam M. Costello (henceforth "I", "me"). I grant everyone ("you") permission to do whatever you like with these files, provided that if you modify them you take reasonable steps to avoid confusing or misleading people about who wrote the modified files (both you and I) or what version they are. All my versions of Par will have version numbers consisting of only digits and periods, so you could distinguish your versions by including some other kind of character. I encourage you to send me your suggestions for improvements. See the Bugs section for my address. Though I have tried to make sure that Par is free of bugs, I make no guarantees about its soundness. Therefore, I am not responsible for any damage resulting from the use of these files. You may alternatively use these files under the MIT License: Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Compilation To compile par, you need an ANSI C compiler. Follow the instructions in the comments in protoMakefile. If your compiler generates any warnings that you think are legitimate, please tell me about them (see the Bugs section). Note that all variables in par are either constant or automatic (or both), which means that par can be made reentrant (if your compiler supports it). Given the right operating system, it should be possible for several par processes to share the same code space and the same data space (but not the same stack, of course) in memory. Synopsis par [help] [version] [B] [P] [Q] [W] [Z] [h[]] [p[]] [r[]] [s[]] [T[]] [w[]] [b[]] [c[]] [d[
]] [E[]] [e[]] [f[]] [g[]] [i[]] [j[]] [l[]] [q[]] [R[]] [t[]] Things enclosed in [square brackets] are optional. Things enclosed in are parameters. Description par is a filter which copies its input to its output, changing all white characters (except newlines) to spaces, and reformatting each paragraph. Paragraphs are separated by protected, blank, and bodiless lines (see the Terminology section for definitions), and optionally delimited by indentation (see the d option in the Options section). Each output paragraph is generated from the corresponding input paragraph as follows: 1) An optional prefix and/or suffix is removed from each input line. 2) The remainder is divided into words (separated by spaces). 3) The words are joined into lines to make an eye-pleasing paragraph. 4) The prefixes and suffixes are reattached. If there are suffixes, spaces are inserted before them so that they all end in the same column. Quick Start par is necessarily complex. For those who wish to use it immediately and understand it later, assign to the PARINIT environment variable the following value: rTbgqR B=.,?'_A_a_@ Q=_s>| The spaces, question mark, apostrophe, greater-than sign, and vertical bar will probably have to be escaped or quoted to prevent your shell from interpreting them. The documentation, though precise, is unfortunately not well-written for the end-user. Your best bet is probably to read quickly the Description, Terminology, Options, and Environment sections, then read carefully the Examples section, referring back to the Options and Terminology sections as needed. For the "power user", a full understanding of par will require multiple readings of the Terminology, Options, Details, and Examples sections. Terminology Miscellaneous terms: charset syntax A way of representing a set of characters as a string. The set includes exactly those characters which appear in the string, except that the underscore (_) is an escape character. Whenever it appears, it must begin one of the following escape sequences: __ = an underscore _s = a space _S = all space characters _b = a backslash (\) _q = a single quote (') _Q = a double quote (") _A = all upper case letters _a = all lower case letters _@ = all neither-case letters _0 = all decimal digits _xhh = the character represented by the two hexadecimal digits hh (which may be upper or lower case) The NUL character must not appear in the string but it may be included in the set with the _x00 sequence. The exact meanings of _S, _A, _a, _@, and _0 are locale-dependent. (Actually, all locales are supposed to agree on _0, but not on the others.) In the default "C" locale: _S includes only space, formfeed, newline, carriage return, tab, and vertical tab; _A includes only A through Z; _a includes only a through z; _@ includes nothing; and _0 includes only 0 through 9. error A condition which causes par to abort. See the Diagnostics section. IP Input paragraph. OP Output paragraph. parameter A symbol which may take on unsigned integral values. There are several parameters whose values affect the behavior of par. Parameters can be assigned values using command line options. Types of characters: alphanumeric character An alphabetic character or decimal digit, _A_a_@_0 in charset syntax (see above). body character A member of the set of characters defined by the PARBODY environment variable (see the Environment section) and/or the B option (see the Options section). protective character A member of the set of characters defined by the PARPROTECT environment variable and/or the P option. quote character A member of the set of characters defined by the PARQUOTE environment variable and/or the Q option. terminal character A member of the set of characters defined by the Z option. Initially, before any Z options have been processed, the set contains period, question mark, exclamation point, and colon. white character A member of the set of characters defined by the W option. Initially, before any W options have been processed, the set contains space, formfeed, newline, carriage return, tab, and vertical tab. Functions: comprelen Given a non-empty sequence of lines, let be their longest common prefix. If the parameter is 0, place a divider just after the leading non-body characters in (at the beginning if there are none). If is 1, place the divider just after the last non-space non-body character in (at the beginning if there is none), then advance the divider over any immediately following spaces. The comprelen of is the number of characters preceding the divider. comsuflen Given a non-empty sequence of lines, let

be the comprelen of . Let be the set of lines which results from stripping the first

characters from each line in . Let be the longest common suffix of the lines in . If is 0, place a divider just before the trailing non-body characters in (at the end if there are none), then advance the divider over all but the last of any immediately following spaces. If is 1, place the divider just before the first non-space non-body character, then back up the divider over one immediately preceding space if there is one. The comsuflen of is the number of characters following the divider. fallback prelen (suflen) The fallback prelen (suflen) of an IP is: the comprelen (comsuflen) of the IP, if the IP contains at least two lines; otherwise, the comprelen (comsuflen) of the block containing the IP, if the block contains at least two lines; otherwise, the length of the longer of the prefixes (suffixes) of the bodiless lines just above and below the block, if the segment containing the block has any bodiless lines; otherwise, 0. (See below for the definitions of block, segment, and bodiless line.) augmented fallback prelen Let be the fallback prelen of an IP. If the IP contains more than one line, or if is 0, then the augmented fallback prelen of the IP is simply . Otherwise, it is plus the number of quote characters immediately following the first characters of the line. quoteprefix The quoteprefix of a line is the longest string of quote characters appearing at the beginning of the line, after this string has been stripped of any trailing spaces. Types of lines: blank line An empty line, or a line whose first character is not protective and which contains only spaces. protected line An input line whose first character is protective. bodiless line A line which is order bodiless for some . order bodiless line There is no such thing as an order 0 bodiless line. Suppose is a a contiguous subsequence of a segment (see below) containing at least two lines, containing no order -1 bodiless lines, bounded above and below by order -1 bodiless lines and/or the beginning/end of the segment. Let

and be the comprelen and comsuflen of . Any member of which, if stripped of its first

and last characters, would be blank (or, if the line was not inserted by the feature and the parameter is non-zero, would consist of the same character repeated at least times), is order bodiless. The first

characters of the bodiless line comprise its prefix; the last characters comprise its suffix. The character which repeats in the middle is called its repeat character. If the middle is empty, the space is taken to be its repeat character. vacant line A bodiless line whose repeat character is the space. superfluous line Only blank and vacant lines may be superfluous. If contiguous vacant lines lie at the beginning or end of a segment, they are all superfluous. But if they lie between two non-vacant lines within a segment, then all are superfluous except one--the one which contains the fewest non-spaces. In case of a tie, the first of the tied lines is chosen. Similarly, if contiguous blank lines lie outside of any segments at the beginning or end of the input, they are all superfluous. But if they lie between two segments and/or protected lines, then all are superfluous except the first. Groups of lines: segment A contiguous sequence of input lines containing no protected or blank lines, bounded above and below by protected lines, blank lines, and/or the beginning/end of the input. block A contiguous subsequence of a segment containing no bodiless lines, bounded above and below by bodiless lines and/or the beginning/end of the segment. Types of words: capitalized word If the parameter is 0, a capitalized word is one which contains at least one alphanumeric character, whose first alphanumeric character is not a lower case letter. If is 1, every word is considered a capitalized word. (See the c option in the Options section.) curious word A word which contains a terminal character such that there are no alphanumeric characters in the word after , but there is at least one alphanumeric character in the word before . Options Any command line argument may begin with one minus sign (-) which is ignored. Generally, more than one option may appear in a single command line argument, but there are exceptions: The help, version, B, P, and Q options must have whole arguments all to themselves. help Causes all remaining arguments to be ignored. No input is read. A usage message is printed on the output briefly describing the options used by par. version Causes all remaining arguments to be ignored. No input is read. "par " followed by its version number is printed on the output. B is a single character, either an equal sign (=), a plus sign (+), or a minus sign (-), and is a string using charset syntax. If is an equal sign, the set of body characters is set to the character set defined by . If is a plus/minus sign, the characters in the set defined by are added/removed to/from the existing set of body characters defined by the PARBODY environment variable and any previous B options. It is okay to add characters that are already in the set or to remove characters that are not in the set. P Just like the B option, except that it applies to the set of protective characters. Q Just like the B option, except that it applies to the set of quote characters. W Just like the B option, except that it applies to the set of white characters. Z Just like the B option, except that it applies to the set of terminal characters. All remaining options are used to set values of parameters. Values set by command line options hold for all paragraphs. Unset parameters are given default values. Any parameters whose default values depend on the IP (namely and ), if left unset, are recomputed separately for each paragraph. The approximate role of each parameter is described here. See the Details section for the rest of the story. The first six parameters, , , , , , and , may be set to any unsigned decimal integer less than 10000. h[] Mainly affects the default values of and . Defaults to 0. If the h option is given without a number, the value 1 is inferred. (See also the p and s options.) p[] The first characters of each line of the OP are copied from the first characters of the corresponding line of the IP. If there are more than +1 lines in the IP, the default value is the comprelen of all the lines in the IP except the first of them. Otherwise, the default value is the augmented fallback prelen of the IP. If the p option is given without a number, is unset, even if it had been set earlier. (See also the h and q options.) r[] If is non-zero, bodiless lines have the number of instances of their repeat characters increased or decreased until the length of the line is . The exact value of affects the definition of bodiless line. Defaults to 0. If the r option is given without a number, the value 3 is inferred. (See also the w option.) s[] The last characters of each line of the OP are copied from the last characters of the corresponding line of the IP. If there are more than +1 lines in the IP, the default value is the comsuflen of all the lines in the IP except the first of them. Otherwise, the default value is the fallback suflen of the IP. If the s option is given without a number, is unset, even if it had been set earlier. (See also the h option.) T[] Tab characters in the input are expanded to spaces, assuming tab stops every columns. Must not be 0. Defaults to 1. If the T option is given without a number, the value 8 is inferred. w[] No line in the OP may contain more than characters, not including the trailing newlines. Defaults to 72. If the w option is given without a number, the value 79 is inferred. The remaining thirteen parameters, , ,

, , , , , , , , , , and , may be set to either 0 or 1. If the number is absent in the option, the value 1 is inferred. b[] If is 1, prefixes may not contain any trailing body characters, and suffixes may not contain any leading body characters. (Actually, the situation is complicated by space characters. See comprelen and comsuflen in the Terminology section.) If is 0, prefixes and suffixes may not contain any body characters at all. Defaults to 0. c[] If is 1, all words are considered capitalized. This currently affects only the application of the g option. Defaults to 0. d[
] If
is 0, each block becomes an IP. If
is 1, each block is subdivided into IPs as follows: Let

be the comprelen of the block. Let a line's status be 1 if its (

+1)st character is a space, 0 otherwise. Every line in the block whose status is the same as the status of the first line will begin a new paragraph. Defaults to 0. E[] If is 1, messages to the user (caused by the help and version options, or by errors) are sent to the error stream instead of the output stream. Defaults to 0. e[] If is 1, superfluous lines withheld from the output. Defaults to 0. f[] If is 1 and is 0, par tries to make the lines in the OP as nearly the same length as possible, even if it means making the OP narrower. Defaults to 0. (See also the j option.) g[] If is 1, then when par is choosing line breaks, whenever it encounters a curious word followed by a capitalized word, it takes one of two special actions. If the two words are separated by a single space in the input, they will be merged into one word with an embedded non-breaking space. If the two words are separated by more than one space, or by a line break, par will insure that they are separated by two spaces, or by a line break, in the output. Defaults to 0. i[] If is 1, then vacant lines inserted because is 1 are invisible; that is, they are not output. If is 0, has no effect. Defaults to 0. (See also the q option.) j[] If is 1, par justifies the OP, inserting spaces between words so that all lines in the OP have length (except the last, if is 0). Defaults to 0. (See also the w, l, and f options.) l[] If is 1, par tries to make the last line of the OP about the same length as the others. Defaults to 0. q[] If is 1, then before each segment is scanned for bodiless lines, par supplies vacant lines between different quotation nesting levels as follows: For each pair of adjacent lines in the segment (scanned from the top down) which have different quoteprefixes, one of two actions is taken. If is 0, and either line consists entirely of quote characters and spaces (or is empty), that line is truncated to the longest common prefix of the two lines (both are truncated if both qualify). Otherwise, a line consisting of the longest common prefix of the two lines is inserted between them. also affects the default value of . Defaults to 0. (See also the p and i options.) R[] If is 1, it is considered an error for an input word to contain more than = ( - - ) characters. Otherwise, such words are chopped after each th character into shorter words. Defaults to 0. t[] Has no effect if is 0 or is 1. Otherwise, if is 0, all lines in the OP have length . If is 1, the length of the lines is decreased until the suffixes touch the body of the OP. Defaults to the logical OR of and . (See also the s, j, w, f, and l options.) If an argument begins with a number, that number is assumed to belong to a p option if it is 8 or less, and to a w option otherwise. If the value of any parameter is set more than once, the last value is used. When unset parameters are assigned default values, and are assigned before , and and are assigned before (because of the dependencies). It is an error if <= + . Environment PARBODY Determines the initial set of body characters (which are used for determining comprelens and comsuflens), using charset syntax. If PARBODY is not set, the set of body characters is initially empty. PARINIT If set, par will read command line arguments from PARINIT before it reads them from the command line. Within the value of PARINIT, arguments are separated by the initial set of white characters. PARPROTECT Determines the set of protective characters, using charset syntax. If PARPROTECT is not set, the set of protective characters is initially empty. PARQUOTE Determines the set of quote characters, using charset syntax. If PARQUOTE is not set, the set of quote characters initially contains only the greater-than sign (>) and the space. If a NUL character appears in the value of an environment variable, it and the rest of the string will not be seen by par. Note that the PARINIT variable, together with the B, P, and Q options, renders the other environment variables unnecessary. They are included for backward compatibility. Details Lines are terminated by newline characters, but the newlines are not considered to be included in the lines. If the last character of the input is a non-newline, a newline will be inferred immediately after it (but if the input is empty, no newline will be inferred; the number of input lines will be 0). Thus, the input can always be viewed as a sequence of lines. Protected lines are copied unchanged from the input to the output. All other input lines, as they are read, have any NUL characters removed, and every white character (except newlines) turned into a space. Actually, each tab character is turned into - ( % ) spaces, where is the number of characters preceding the tab character on the line (evaluated after earlier tab characters have been expanded). Blank lines in the input are transformed into empty lines in the output. If is 0, all bodiless lines are vacant, and they are all simply stripped of trailing spaces before being output. If is not 0, only vacant lines whose suffixes have length 0 are treated that way; other bodiless lines have the number of instances of their repeat characters increased or decreased until the length of the line is . If is 1, superfluous lines are not output. If and are both 1, there may be invisible lines; they are not output. The input is divided into segments, which are divided into blocks, which are divided into IPs. The exact process depends on the values of and

(see q and d in the Options section). The remainder of this section describes the process which is applied independently to each IP to construct the corresponding OP. After the values of the parameters are determined (see the Options section), the first characters and the last characters of each input line are removed and remembered. It is an error for any line to contain fewer than + characters. The remaining text is treated as a sequence of characters, not lines. The text is broken into words, which are separated by spaces. That is, a word is a maximal sub-sequence of non-spaces. If is 1, some words might be merged (see g in the Options section). The first word includes any spaces that precede it on the same line. Let = - - . If is 0, some words may get chopped up at this point (see R in the Options section). The words are reassembled, preserving their order, into lines. If is 0, adjacent words within a line are separated by a single space (or sometimes two if is 1), and line breaks are chosen so that the paragraph satisfies the following properties: 1) No line contains more than characters. 2) If is 1, the difference between the lengths of the shortest and longest lines is as small as possible. 3) The shortest line is as long as possible, subject to properties 1 and 2. 4) Let be if is 0, or the length of the longest line if is 1. The sum of the squares of the differences between and the lengths of the lines is as small as possible, subject to properties 1, 2, and 3. If is 0, the last line does not count as a line for the purposes of properties 2, 3, and 4 above. If all the words fit on a single line, the properties as worded above don't make much sense. In that case, no line breaks are inserted. If is 1, adjacent words within a line are separated by one space (or sometimes two if is 1) plus zero or more extra spaces. The value of is disregarded, and line breaks are chosen so that the paragraph satisfies the following properties: 1) Every line contains exactly characters. 2) The largest inter-word gap is as small as possible, subject to property 1. (An inter-word gap consists only of the extra spaces, not the regular spaces.) 3) The sum of the squares of the lengths of the inter-word gaps is as small as possible, subject to properties 1 and 2. If is 0, the last line does not count as a line for the purposes of property 1, and it does not require or contain any extra spaces. Extra spaces are distributed as uniformly as possible among the inter-word gaps in each line. In a justified paragraph, every line must contain at least two words, but that's not always possible to accomplish. If the paragraph cannot be justified, it is considered an error. If the number of lines in the resulting paragraph is less than , empty lines are added at the end to bring the number of lines up to . If is 0 and is 1, is changed to be the length of the longest line. If is not 0, each line is padded at the end with spaces to bring its length up to . To each line is prepended characters. Let be the number of lines in the IP, let be the augmented fallback prelen of the IP, and let be the fallback suflen of the IP. The characters which are prepended to the th line are chosen as follows: 1) If <= , the characters are copied from the ones that were removed from the beginning of the th input line. 2) If > > , the characters are copied from the ones that were removed from the beginning of the last input line. 3) If > and <= , the first min(,) of the characters are copied from the ones that were removed from the beginning of the last input line, and the rest are all spaces. Then to each line is appended characters. The characters which are appended to the th line are chosen as follows: 1) If <= , the characters are copied from the ones that were removed from the end of the nth input line. 2) If > > , the characters are copied from the ones that were removed from the end of the last input line. 3) If > and <= , the first min(,) of the characters are copied from the ones that were removed from the beginning of the last input line, and the rest are all spaces. Finally, the lines are printed to the output as the OP. Diagnostics If there are no errors, par returns EXIT_SUCCESS (see ). If there is an error, an error message will be printed to the output, and par will return EXIT_FAILURE. If the error is local to a single paragraph, the preceding paragraphs will have been output before the error was detected. Line numbers in error messages are local to the IP in which the error occurred. All error messages begin with "par error:" on a line by itself. Error messages concerning command line or environment variable syntax are accompanied by the same usage message that the help option produces. Of course, trying to print an error message would be futile if an error resulted from an output function, so par doesn't bother doing any error checking on output functions. Examples The superiority of par's dynamic programming algorithm over a greedy algorithm (such as the one used by fmt) can be seen in the following example: Original paragraph (note that each line begins with 8 spaces): We the people of the United States, in order to form a more perfect union, establish justice, insure domestic tranquility, provide for the common defense, promote the general welfare, and secure the blessing of liberty to ourselves and our posterity, do ordain and establish the Constitution of the United States of America. After a greedy algorithm with width = 39: We the people of the United States, in order to form a more perfect union, establish justice, insure domestic tranquility, provide for the common defense, promote the general welfare, and secure the blessing of liberty to ourselves and our posterity, do ordain and establish the Constitution of the United States of America. After "par 39": We the people of the United States, in order to form a more perfect union, establish justice, insure domestic tranquility, provide for the common defense, promote the general welfare, and secure the blessing of liberty to ourselves and our posterity, do ordain and establish the Constitution of the United States of America. The line breaks chosen by par are clearly more eye-pleasing. par is most useful in conjunction with the text-filtering features of an editor, such as the ! commands of vi. You may wish to add the following lines to your .exrc file: " use Bourne shell for speed: set shell=/bin/sh " " reformat paragraph with no arguments: map ** {!}par^M} " " reformat paragraph with arguments: map *^V {!}par Note that the leading spaces must be removed, and that what is shown as ^M and ^V really need to be ctrl-M and ctrl-V. Also note that the last map command contains two spaces following the ctrl-V, plus one at the end of the line. To reformat a simple paragraph delimited by blank lines in vi, you can put the cursor anywhere in it and type "**" (star star). If you need to supply arguments to par, you can type "* " (star space) instead, then type the arguments. The rest of this section is a series of before-and-after pictures showing some typical uses of par. In all cases, no environment variables are set. Before: /* We the people of the United States, */ /* in order to form a more perfect union, */ /* establish justice, */ /* insure domestic tranquility, */ /* provide for the common defense, */ /* promote the general welfare, */ /* and secure the blessing of liberty */ /* to ourselves and our posterity, */ /* do ordain and establish the Constitution */ /* of the United States of America. */ After "par 59": /* We the people of the United States, in */ /* order to form a more perfect union, establish */ /* justice, insure domestic tranquility, provide */ /* for the common defense, promote the general */ /* welfare, and secure the blessing of liberty */ /* to ourselves and our posterity, do ordain */ /* and establish the Constitution of the United */ /* States of America. */ Or after "par 59f": /* We the people of the United States, */ /* in order to form a more perfect union, */ /* establish justice, insure domestic */ /* tranquility, provide for the common */ /* defense, promote the general welfare, */ /* and secure the blessing of liberty to */ /* ourselves and our posterity, do ordain */ /* and establish the Constitution of the */ /* United States of America. */ Or after "par 59l": /* We the people of the United States, in */ /* order to form a more perfect union, establish */ /* justice, insure domestic tranquility, */ /* provide for the common defense, promote */ /* the general welfare, and secure the */ /* blessing of liberty to ourselves and our */ /* posterity, do ordain and establish the */ /* Constitution of the United States of America. */ Or after "par 59lf": /* We the people of the United States, */ /* in order to form a more perfect union, */ /* establish justice, insure domestic */ /* tranquility, provide for the common */ /* defense, promote the general welfare, */ /* and secure the blessing of liberty */ /* to ourselves and our posterity, do */ /* ordain and establish the Constitution */ /* of the United States of America. */ Or after "par 59lft0": /* We the people of the United States, */ /* in order to form a more perfect union, */ /* establish justice, insure domestic */ /* tranquility, provide for the common */ /* defense, promote the general welfare, */ /* and secure the blessing of liberty */ /* to ourselves and our posterity, do */ /* ordain and establish the Constitution */ /* of the United States of America. */ Or after "par 59j": /* We the people of the United States, in */ /* order to form a more perfect union, establish */ /* justice, insure domestic tranquility, provide */ /* for the common defense, promote the general */ /* welfare, and secure the blessing of liberty */ /* to ourselves and our posterity, do ordain and */ /* establish the Constitution of the United */ /* States of America. */ Or after "par 59jl": /* We the people of the United States, */ /* in order to form a more perfect */ /* union, establish justice, insure domestic */ /* tranquility, provide for the common defense, */ /* promote the general welfare, and secure */ /* the blessing of liberty to ourselves and */ /* our posterity, do ordain and establish the */ /* Constitution of the United States of America. */ Before: Preamble We the people of the United States, to the US in order to form Constitution a more perfect union, establish justice, insure domestic tranquility, provide for the common defense, promote the general welfare, and secure the blessing of liberty to ourselves and our posterity, do ordain and establish the Constitution of the United States of America. After "par 52h3": Preamble We the people of the United to the US States, in order to form a Constitution more perfect union, establish justice, insure domestic tranquility, provide for the common defense, promote the general welfare, and secure the blessing of liberty to ourselves and our posterity, do ordain and establish the Constitution of the United States of America. Before: 1 We the people of the United States, 2 in order to form a more perfect union, 3 establish justice, 4 insure domestic tranquility, 5 provide for the common defense, 6 promote the general welfare, 7 and secure the blessing of liberty 8 to ourselves and our posterity, 9 do ordain and establish the Constitution 10 of the United States of America. After "par 59p12l": 1 We the people of the United States, in order to 2 form a more perfect union, establish justice, 3 insure domestic tranquility, provide for the 4 common defense, promote the general welfare, 5 and secure the blessing of liberty to ourselves 6 and our posterity, do ordain and establish the 7 Constitution of the United States of America. Before: > > We the people > > of the United States, > > in order to form a more perfect union, > > establish justice, > > ensure domestic tranquility, > > provide for the common defense, > > Promote the general welfare, > and secure the blessing of liberty > to ourselves and our posterity, > do ordain and establish > the Constitution of the United States of America. After "par 52": > > We the people of the United States, in > > order to form a more perfect union, > > establish justice, ensure domestic > > tranquility, provide for the common > > defense, > > Promote the general welfare, and secure > the blessing of liberty to ourselves and > our posterity, do ordain and establish > the Constitution of the United States of > America. Before: > We the people > of the United States, > in order to form a more perfect union, > establish justice, > ensure domestic tranquility, > provide for the common defense, > Promote the general welfare, > and secure the blessing of liberty > to ourselves and our posterity, > do ordain and establish > the Constitution of the United States of America. After "par 52d": > We the people of the United States, > in order to form a more perfect union, > establish justice, ensure domestic > tranquility, provide for the common > defense, > Promote the general welfare, and secure > the blessing of liberty to ourselves and > our posterity, do ordain and establish > the Constitution of the United States of > America. Before: # 1. We the people of the United States. # 2. In order to form a more perfect union. # 3. Establish justice, ensure domestic # tranquility. # 4. Provide for the common defense # 5. Promote the general welfare. # 6. And secure the blessing of liberty # to ourselves and our posterity. # 7. Do ordain and establish the Constitution. # 8. Of the United States of America. After "par 37p13dh": # 1. We the people of the # United States. # 2. In order to form a more # perfect union. # 3. Establish justice, # ensure domestic # tranquility. # 4. Provide for the common # defense # 5. Promote the general # welfare. # 6. And secure the blessing # of liberty to ourselves # and our posterity. # 7. Do ordain and establish # the Constitution. # 8. Of the United States of # America. Before: /*****************************************/ /* We the people of the United States, */ /* in order to form a more perfect union, */ /* establish justice, insure domestic */ /* tranquility, */ /* */ /* */ /* [ provide for the common defense, ] */ /* [ promote the general welfare, ] */ /* [ and secure the blessing of liberty ] */ /* [ to ourselves and our posterity, ] */ /* [ ] */ /* */ /* do ordain and establish the Constitution */ /* of the United States of America. */ /******************************************/ After "par 42r": /********************************/ /* We the people of the */ /* United States, in order to */ /* form a more perfect union, */ /* establish justice, insure */ /* domestic tranquility, */ /* */ /* */ /* [ provide for the common ] */ /* [ defense, promote the ] */ /* [ general welfare, and ] */ /* [ secure the blessing of ] */ /* [ liberty to ourselves ] */ /* [ and our posterity, ] */ /* [ ] */ /* */ /* do ordain and establish the */ /* Constitution of the United */ /* States of America. */ /********************************/ Or after "par 42re": /********************************/ /* We the people of the */ /* United States, in order to */ /* form a more perfect union, */ /* establish justice, insure */ /* domestic tranquility, */ /* */ /* [ provide for the common ] */ /* [ defense, promote the ] */ /* [ general welfare, and ] */ /* [ secure the blessing of ] */ /* [ liberty to ourselves ] */ /* [ and our posterity, ] */ /* */ /* do ordain and establish the */ /* Constitution of the United */ /* States of America. */ /********************************/ Before: Joe Public writes: > Jane Doe writes: > > > > > > I can't find the source for uncompress. > Oh no, not again!!! > > > Isn't there a FAQ for this? > > That wasn't very helpful, Joe. Jane, just make a link from uncompress to compress. After "par 40q": Joe Public writes: > Jane Doe writes: > > > > I can't find the source for > > uncompress. > > Oh no, not again!!! > > > Isn't there a FAQ for this? > That wasn't very helpful, Joe. Jane, just make a link from uncompress to compress. Or after "par 40qe": Joe Public writes: > Jane Doe writes: > > > I can't find the source for > > uncompress. > > Oh no, not again!!! > > Isn't there a FAQ for this? That wasn't very helpful, Joe. Jane, just make a link from uncompress to compress. Or after "par 40qi": Joe Public writes: > Jane Doe writes: > > > > > > I can't find the source for > > uncompress. > Oh no, not again!!! > > > Isn't there a FAQ for this? > > That wasn't very helpful, Joe. Jane, just make a link from uncompress to compress. Or after "par 40qie": Joe Public writes: > Jane Doe writes: > > I can't find the source for > > uncompress. > Oh no, not again!!! > > Isn't there a FAQ for this? That wasn't very helpful, Joe. Jane, just make a link from uncompress to compress. Before: I sure hope there's still room in Dr. Jones' section of archaeology. I've heard he's the bestest. [sic] After "par 50g": I sure hope there's still room in Dr. Jones' section of archaeology. I've heard he's the bestest. [sic] Or after "par 50gc": I sure hope there's still room in Dr. Jones' section of archaeology. I've heard he's the bestest. [sic] Before: John writes: : Mary writes: : + Anastasia writes: : + > Hi all! : + Hi Ana! : Hi Ana & Mary! Please unsubscribe me from alt.hello. After "par Q+:+ q": John writes: : Mary writes: : : + Anastasia writes: : + : + > Hi all! : + : + Hi Ana! : : Hi Ana & Mary! Please unsubscribe me from alt.hello. Before: amc> The b option was added primarily to deal with amc> this new style of quotation amc> which became popular after Par 1.41 was released. amc> amc> Par still pays attention to body characters. amc> Par should not mistake "Par" for part of the prefix. amc> Par should not mistake "." for a suffix. After "par B=._A_a 50bg": amc> The b option was added primarily to amc> deal with this new style of quotation amc> which became popular after Par 1.41 amc> was released. amc> amc> Par still pays attention to body amc> characters. Par should not mistake amc> "Par" for part of the prefix. Par amc> should not mistake "." for a suffix. Limitations The feature guesses wrong in cases like the following: I calc'd the approx. Fermi level to 3 sig. digits. With = 1, par will incorrectly assume that "approx." ends a sentence. If the input were: I calc'd the approx. Fermi level to 3 sig. digits. then par would refuse to put a line break between "approx." and "Fermi" in the output, mainly to avoid creating the first situation (in case the paragraph were to be fed back through par again). This non-breaking space policy does come in handy for cases like "Mr. Johnson" and "Jan. 1", though. The feature only goes one way. par can preserve wide sentence breaks in a paragraph, or remove them, but it can't insert them if they aren't already in the input. If you use tabs, you may not like the way par handles (or doesn't handle) them. It expands them into spaces. I didn't let par output tabs because tabs don't make sense. Not everyone's terminal has the same tab settings, so text files containing tabs are sometimes mangled. In fact, almost every text file containing tabs gets mangled when something is inserted at the beginning of each line (when quoting e-mail or commenting out a section of a shell script, for example), making them a pain to edit. In my opinion, the world would be a nicer place if everyone stopped using tabs, so I'm doing my part by not letting par output them. (Thanks to Eric Stuebe for showing me the light about tabs.) There is currently no way for the length of the output prefix to differ from the length of the input prefix. Ditto for the suffix. I may consider adding this capability in a future release, but right now I'm not sure how I'd want it to work. Apologies Par began in July 1993 as a small program designed to do one narrow task: reformat a single paragraph that might have a border on either side. It was pretty clean back then. Over the next three months, it very rapidly expanded to handle multiple paragraphs, offer more options, and take better guesses, at the cost of becoming extremely complex, and very unclean. It is nowhere near the optimal design for the larger task it now tries to address. Its only redeeming features are that it is extremely useful (I find it indispensable), extremely portable, and very stable since version 1.41 released on 1993-Oct-31. Back in 1993 I had very little experience at writing documentation for users, so the documentation for Par became rather nightmarish. There is no separation between how-it-works (which is painfully complex) and how-to-use-it (which is fairly simple, if you can ever figure it out). Someday I ought to reexamine the problem, and redesign a new, clean solution from scratch. I don't know when I might get enough free time to start on such a project. Text files may be obsolete by then. Bugs If I knew of any bugs, I wouldn't release the package. Of course, there may be bugs that I haven't yet discovered. If you find any bugs (in the program or in the documentation), or if you have any suggestions, please contact me: http://www.nicemice.net/amc/ When reporting a bug, please include the exact input and command line options used, and the version number of par, so that I can reproduce it. The latest release of Par is available on the Web at: http://www.nicemice.net/par/ I don't expect these URLs to change in the forseeable future, but if they do, I'll try to leave forward pointers. Par-1.53.0/releasenotes0000600000175000037200000003666513633300162013035 0ustar amcengreleasenotes last touched in Par 1.53.0 last meaningful change in Par 1.53.0 Copyright 1993, 1996, 2000, 2001, 2020 Adam M. Costello Each entry below describes changes since the previous version. Par 1.53.0 released 2020-Mar-14 Fixed the following bugs: An unintended bad interaction between and . The specification was inconsistent. Although it said that the lines inserted by the feature were vacant, the feature could interpret the quote character of inserted lines as a repeat character, in which case the lines were not vacant (according to the definition), and more quote/repeat characters would be inserted to extend the line to the full width, which no one would ever want. The definition of "bodiless line" is revised so that lines inserted by the feature are excluded from consideration by the feature. A printf format string mismatch (ptrdiff_t vs. %d), reported by Quentin Barnes (qbarnes at gmail.com). protoMakefile's clean target removed par rather than par$E, reported by George V. Reilly (george at reilly.org). Added the following features: Locale support for single-byte character sets. The previous verson, 1.52, attempted to do this in one line of code (setlocale()), but it's not that simple. Versions before 1.52 gave no thought to character sets other than US-ASCII and did not handle them entirely correctly. Calling setlocale() in version 1.52 corrected some flaws but not all, and created one new flaw. This version and the previous two all have the same character handling in the "C" locale and when processing US-ASCII text; differences arise only when processing non-US-ASCII text in another locale. In versions before 1.52 the implementation assumed that "uppercase letter" means only the 26 characters A-Z and that "lowercase letter" means only the 26 characters a-z, and the specification assumed that every letter is either upper case or lower case. These assumptions hold for US-ASCII, but not for most other character sets; therefore versions before 1.52 did not really support non-US-ASCII text. Version 1.52, by calling setlocale(), relaxed the three assumptions in the implementation but not the assumption in the specification, and inadvertantly caused the implementation to deviate from the specification by converting all space characters to spaces rather than converting only the specified white characters, which is not necessarily what you want (for example, you probably don't want no-break space converted to space, but some locales on some platforms have been known to classify no-break space as white-space, like FreeBSD did in 2004). This version fixes the specification by introducing the concept of "neither-case letter" and redefining "alphanumeric character" to include it, and fixes the implementation to convert only the white characters to spaces. It also makes the white characters configurable so that the version 1.52 space-conversion behavior can be restored if desired (W=_S). Note that Par still assumes constant display width per byte, which is not true for UTF-8 nor ISO-2022-*, but is true for most single-byte charsets and for EUC-* text without the single-shift-in/out codes. The W option, for configuring the set of white characters. The Z option, for configuring the set of terminal characters. The _@ escape sequence (neither-case letter) in charset syntax. The _S escape sequence (any space) in charset syntax. Added _@ and apostrophe to the set of body characters in PARINIT. Add #includes for whatever interfaces are used rather than depending on included files to #include other files. In protoMakefile introduced CPPFLAGS and CFLAGS (default empty) into the default definition of CC. Added a test-par script and a test target in protoMakefile. Fixed a misspelling (preceed => precede) in par.doc and par.1. Changed the top-of-file comment convention so that every release won't need to touch every file (this is the last time). Updated the author contact information. Clarified the license and added the MIT License as an alternative. Adopted a modern version number format, with minor and patch numbers as dot-separated integers rather than adjacent single digits. Par 1.52 released 2001-Apr-29 Fixed a portability problem regarding unsigned char versus char. (This was a potential problem only on platforms where char is a non-two's-complement signed type, which is very few, if any.) Added a call to setlocale(), for 8-bit character support, requested by Alex Postnikov (apost at math.berkeley.edu) and Oliver Fromme (olli at secnetix.de). Added some unnecessary parentheses, braces, and initialization, to quiet the more aggressive compiler warnings. (This was suggested back in 1993 by Thomas E. Dickey (dickey at software.org) but I refused. I guess my attitude has changed.) Changed the EXAMPLES section of par.1 to use the constant-width font rather than constant-spaced Roman, suggested by Carl Lowenstein (cdl at mpl.ucsd.edu). Reorganized releasenotes to put the most recent version first, and rearranged the email addresses to confuse address harvesters. Par 1.51 released 2000-Feb-24 Updated the author contact information. Relaxed the copyright restrictions. Added comma to the recommended set of body characters in PARINIT. Par 1.50 released 1996-Feb-11 Added the following features: The T option, suggested by Jules Junker (jjunker at eos.hitc.com). The b option. Loosened the terms of the Copyright. Changed protoMakefile: Added the E and O macros, suggested by Peter A. Getterman (pgutterman at worldbank.org). Added sensible default values for all macros. Added question-mark to the recommended set of body characters. Restored documentation of the number-without-a-letter shortcut command-line option, which got lost between versions 1.00 and 1.10. Its absence was noted by David W. Sanderson (dws at ssec.wisc.edu). Added .exrc examples, suggested by Alex Matulich (matuli_a at marlin.navsea.navy.mil), though I used my own .exrc. Added the Apologies section to par.doc and par.1. Made many other tweeks to the documentation. Removed the useless synopsis from the runtime help message. Par 1.41 released 1993-Oct-31 Moved the former Release Notes section of par.doc into its own file. Fixed the following bugs: A couple of inconsistencies of style in the code, pointed out by Thomas E. Dickey (dickey at software.org). If and were 1 and a one-line paragraph beginning with quote characters was reformatted into a multi-line paragraph, the new lines began with spaces instead of quote characters. This was because the policy for copying prefixes used the fallback prelen rather than the augmented version of it used for computing the default value of . Now both use the same formula. Thanks go to Steven King (king at rtsg.mot.com) for reporting the problem. If the t option were given without a number, it was unset instead of being set to 1. Added the following feature: The E option, suggested by Alex Matulich (alex at bilver.oau.org). Altered the terminology: Added the term "augmented fallback prelen". Added to the Rights and Responsibilities section of par.doc a guideline for handling version numbers in patched versions of Par. Added a useful suggestion to protoMakefile. Par 1.40 released 1993-Oct-10 Fixed the following bugs: The phrase "containing at least two lines" was left out of the definition of "vacant line" in par.doc and par.1, although the code implemented the correct definition. (The phrase now appears in the definition of "order bodiless line".) There was still a flaw in the design of the feature. If two adjacent lines had quoteprefixes neither of which was a prefix of the other, no line would be inserted between them, possibly causing other inserted lines not to be vacant. Now it should be true that every line inserted or truncated by the feature will turn out to be vacant. When began affecting the default value of (as of Par 1.20), it should also have begun affecting the choice of source of characters for the suffixes of lines in OPs. Added the following features: The i option, suggested by Alan Barrett (barrett at ee.und.ac.za). The e option, inspired by a suggestion from Tim Pointing (tim at ben.dciem.dnd.ca). The r option. The p, s, and w options are now accepted without numbers. par no longer gives up so easily when choosing default values for and for an IP with less than +2 lines, nor when choosing the source of characters for the prefix and suffix of the th output line when > and <= . These are incompatible changes, but I cannot imagine anyone preferring the old behavior. Altered the terminology: Added the terms "bodiless line" (a generalization of "vacant line"), "fallback prelen", and "fallback suflen". Made miscellaneous changes to the documentation, including the addition of the Quick Start section. Par 1.32 released 1993-Sep-13 Fixed the following bugs: par could crash when the + or - operator was used with the B, P, and Q options. Thanks go to Andrew Cashin (splat at deakin.oz.au) for reporting this. If were 1 and two adjacent lines had different quoteprefixes, one of which was a prefix of the other, and only the line with the shorter quoteprefix contained a non-quote character, then nothing would be altered. According to par.doc 1.31, this was correct, but since neither line is vacant, I consider this a bug in the design of the feature. Now the longer quoteprefix will be truncated to match the shorter one, and will therefore be vacant. Thanks go to Andrew Cashin (splat at deakin.oz.au) for asking about this. Made slight changes to the documentation. Par 1.31 released 1993-Sep-07 The version number is 1.31 rather than 1.40 because all added features are really just enhancements of existing features. Fixed the following bug: In par.doc, in the example of a paragraph produced by a greedy algorithm, the word "establish" appeared twice in a row. Thanks go to Daniel Kussendrager (daniel at astro.rug.nl) for first pointing this out. (The example is now even better because the paragraph looks even worse than before.) Added the following features: A usage message to accompany command line or environment variable syntax errors, first suggested by Karl Stiefvater (qarl at ecl.wustl.edu). The help and c options. The B, P, and Q options, which render PARBODY, PARPROTECT, and PARQUOTE no longer necessary. They are retained, though, for compatibility and convenience. The _b, _q, and _Q escape sequences for charset syntax. Added the term "charset syntax". Isolated the character set code in charset.c and charset.h. Par 1.30 released 1993-Aug-18 Since Par 1.20 was posted to comp.sources.misc, I have made only backward-compatible changes in Par 1.30. Fixed the following bugs: One wrong word in par.c sometimes caused par to crash. Thanks go to Contr Karl Vogel (vogelke at c-17igp.wpafb.af.mil) for sending me an input file that caused a crash. Too-long words were chopped up before the first word in a paragraph was expanded to include initial spaces, allowing impossibility #1 to occur. The order of the two operations has been reversed. Thanks go to Andrew Cashin (splat at deakin.oz.au) for reporting the error message. Added the following features: The g option, motivated by suggestions from several people. The q option, inspired by a suggestion from Andrew Cashin (splat at deakin.oz.au). The R option (my attempt to squash a bad idea from Par 1.00). The PARQUOTE environment variable (comes with the q option). The PARPROTECT environment variable, inspired by a suggestion from Dennis Flaherty (dennisf at se01.elk.miles.com). Altered the terminology: Several terms have been added, and the meaning of some terms has been slightly modified. This is a change in the language used to describe par's behavior, not a change in par's actual behavior. Added a clean target to protoMakefile, suggested by Hal Jespersen (hlj at posix.com). Par 1.20 released 1993-Aug-10 Since Par 1.10 was distributed to no one, I've made some more incompatible changes in Par 1.20. Added the following features: The d option. Paragraphs are now separated by vacant lines, not just blank lines. now affects not only but also . Par 1.10 released 1993-Aug-02 Fixed the following bugs: In reformat.c I used sprintf() but forgot to #include . I forgot to verify that > + . The first word of a paragraph was expanded to include initial white characters, not just spaces, contrary to par.doc. Some invalid options were not complained about. NUL characters in the input were not handled. A pointer foul-up in freelines() in par.c could cause a crash. Added the following features: The f, j, and t options. The PARBODY environment variable. Multiple options may be concatenated into a single argument. Removed the m option: Its function is better performed by the f and t options. Normally I would avoid making incompatible changes, unless I were doing a complete overhaul of the whole program, in which case I'd make the version number 2.00 to alert users to possible incompatibilities. However, in this particular instance I allowed an incompatibility in a minor upgrade because version 1.00 was distributed to only four people. Changed the handling of white characters: par now changes all of them (except newlines) to spaces as they are read. This is another incompatible change, excused for the same reason. Made all error messages begin with "par error:". Par 1.00 released 1993-Jul-25 The first release.