Subversion Repositories planix.SVN

#include <u.h>
#include <libc.h>
#include <bio.h>
#include <ctype.h>

/*
 * block up paragraphs, possibly with indentation
 */

int extraindent = 0;            /* how many spaces to indent all lines */
int indent = 0;                 /* current value of indent, before extra indent */
int length = 70;                /* how many columns per output line */
int join = 1;                   /* can lines be joined? */
int maxtab = 8;
Biobuf bin;
Biobuf bout;

typedef struct Word Word;
struct Word{
        int     bol;
        int     indent;
        char    text[1];
};

void    fmt(void);

void
usage(void)
{
        fprint(2, "usage: %s [-j] [-i indent] [-l length] [file...]\n", argv0);
        exits("usage");
}

void
main(int argc, char **argv)
{
        int i, f;
        char *s, *err;

        ARGBEGIN{
        case 'i':
                extraindent = atoi(EARGF(usage()));
                break;
        case 'j':
                join = 0;
                break;
        case 'w':
        case 'l':
                length = atoi(EARGF(usage()));
                break;
        default:
                usage();
        }ARGEND

        if(length <= indent){
                fprint(2, "%s: line length<=indentation\n", argv0);
                exits("length");
        }

        s=getenv("tabstop");
        if(s!=nil && atoi(s)>0)
                maxtab=atoi(s);
        err = nil;
        Binit(&bout, 1, OWRITE);
        if(argc <= 0){
                Binit(&bin, 0, OREAD);
                fmt();
        }else{
                for(i=0; i<argc; i++){
                        f = open(argv[i], OREAD);
                        if(f < 0){
                                fprint(2, "%s: can't open %s: %r\n", argv0, argv[i]);
                                err = "open";
                        }else{
                                Binit(&bin, f, OREAD);
                                fmt();
                                Bterm(&bin);
                                if(i != argc-1)
                                        Bputc(&bout, '\n');
                        }
                }
        }
        exits(err);
}

int
indentof(char **linep)
{
        int i, ind;
        char *line;

        ind = 0;
        line = *linep;
        for(i=0; line[i]; i++)
                switch(line[i]){
                default:
                        *linep = line;
                        return ind;
                case ' ':
                        ind++;
                        break;
                case '\t':
                        ind += maxtab;
                        ind -= ind%maxtab;
                        break;
                }
                        
        /* plain white space doesn't change the indent */
        *linep = "";
        return indent;
}

Word**
addword(Word **words, int *nwordp, char *s, int l, int indent, int bol)
{
        Word *w;

        w = malloc(sizeof(Word)+l+1);
        memmove(w->text, s, l);
        w->text[l] = '\0';
        w->indent = indent;
        w->bol = bol;
        words = realloc(words, (*nwordp+1)*sizeof(Word*));
        words[(*nwordp)++] = w;
        return words;
}

Word**
parseline(char *line, Word **words, int *nwordp)
{
        int ind, l, bol;

        ind = indentof(&line);
        indent = ind;
        bol = 1;
        for(;;){
                /* find next word */
                while(*line==' ' || *line=='\t')
                        line++;
                if(*line == '\0'){
                        if(bol)
                                return addword(words, nwordp, "", 0, -1, bol);
                        break;
                }
                /* how long is this word? */
                for(l=0; line[l]; l++)
                        if(line[l]==' ' || line[l]=='\t')
                                break;
                words = addword(words, nwordp, line, l, indent, bol);
                bol = 0;
                line += l;
        }
        return words;
}

void
printindent(int w)
{
        while(w >= maxtab){
                Bputc(&bout, '\t');
                w -= maxtab;
        }
        while(w > 0){
                Bputc(&bout, ' ');
                w--;
        }
}

/* give extra space if word ends with period, etc. */
int
nspaceafter(char *s)
{
        int n;

        n = strlen(s);
        if(n < 2)
                return 1;
        if(isupper(s[0]) && n < 4)
                return 1;
        if(strchr(".!?", s[n-1]) != nil)
                return 2;
        return 1;
}
        

void
printwords(Word **w, int nw)
{
        int i, j, n, col, nsp;

        /* one output line per loop */
        for(i=0; i<nw; ){
                /* if it's a blank line, print it */
                if(w[i]->indent == -1){
                        Bputc(&bout, '\n');
                        if(++i == nw)   /* out of words */
                                break;
                }
                /* emit leading indent */
                col = extraindent+w[i]->indent;
                printindent(col);
                /* emit words until overflow; always emit at least one word */
                for(n=0;; n++){
                        Bprint(&bout, "%s", w[i]->text);
                        col += utflen(w[i]->text);
                        if(++i == nw)
                                break;  /* out of words */
                        if(w[i]->indent != w[i-1]->indent)
                                break;  /* indent change */
                        nsp = nspaceafter(w[i-1]->text);
                        if(col+nsp+utflen(w[i]->text) > extraindent+length)
                                break;  /* fold line */
                        if(!join && w[i]->bol)
                                break;
                        for(j=0; j<nsp; j++)
                                Bputc(&bout, ' ');      /* emit space; another word will follow */
                        col += nsp;
                }
                /* emit newline */
                Bputc(&bout, '\n');
        }
}

void
fmt(void)
{
        char *s;
        int i, nw;
        Word **w;

        nw = 0;
        w = nil;
        while((s = Brdstr(&bin, '\n', 1)) != nil){
                w = parseline(s, w, &nw);
                free(s);
        }
        printwords(w, nw);
        for(i=0; i<nw; i++)
                free(w[i]);
        free(w);
}