C-Code

/****************************************************
 * wblocksatz.c  Textformatierung im Blocksatz
 *               wcs-Variante (wide character strings) 
 ****************************************************/
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <wchar.h>
#include <wctype.h>
#include <locale.h>

#define LINE_BUFFER_SIZE  200
#define WORDS_PER_LINE  50

// Spaltenbreite global
int gcolumn_width;


// Textparser (Wortsuche)
wchar_t* wparse_text(wchar_t *start, int maxlen, int backstep) {
	static wchar_t *w;		  // begin of word
	static wchar_t *p;		  // pointer to next char
	static wchar_t csav=0;	  // char replaced by '\0'
	
	if (csav) {
		*p = csav;
		csav = 0;
	}
	if (backstep)
		return (w)?p=w:NULL;
	if (start)
		p = start;
	while (*p && iswspace(*p))
		p++;
	w = p;
	while (*p && !iswspace(*p) && p - w < maxlen)
		p++;
	if (*p) {
		csav = *p;
		*p = L'\0';
	}
	return (p - w)?w:NULL;
}

// Hole naechstes Wort mit Maximallaenge
wchar_t *wgetword(wchar_t *word, int maxlen) {
	return wparse_text(word, maxlen, 0);
}

// Letztes Wort wieder einstellen
wchar_t *wungetword(void) {
	return wparse_text(NULL, 0, 1);
}

// Ausgabe einer Textzeile im Blocksatz
// nwrd  : Anzahl Worte
// nspc  : Anzahl Blanks zur Verteilung
// words : Zeiger auf Wortliste
void wprint_line(int nwrd, int nspc, wchar_t **words) {
	int min_spc, res_spc;
	int gap, ng, nw;

	--nwrd;
	min_spc = (nwrd && nspc) ? (nspc/nwrd) : 1;
	res_spc = nspc - min_spc*nwrd;
	for (nw=0; nw<=nwrd; nw++) {
		wprintf(L"%ls", words[nw]);
		if (nw < nwrd) {
			gap =  min_spc + ((nwrd-nw<=res_spc)?1:0);
			for (ng=0; ng<gap; ng++)
				putwchar(L' ');
		}
	}
	putwchar(L'\n');
}
	
// Hauptfunktion: Textformatierung im Blocksatz
void wformat_text(wchar_t *text) {
    wchar_t line_buffer[LINE_BUFFER_SIZE];
	wchar_t *words_list[WORDS_PER_LINE];
	wchar_t *word, *lbpos;
    int cwords = 0;
    int clines = 0;
	int cleft, wlen;

    lbpos = line_buffer;
    cleft = gcolumn_width;
        
	if ((word = wgetword(text, gcolumn_width)) != NULL) {
	do {
		wlen = wcslen(word);
        wmemcpy(lbpos, word, wlen+1);
		words_list[cwords++] = lbpos;
        lbpos += wlen + 1;
		cleft -= wlen;
		if (cleft < cwords) {
			if (cleft < cwords-1) {
				wungetword();
                cleft += wlen;
				cwords--;
			}
			wprint_line(cwords, cleft, words_list);
			clines++;
			cwords = 0;
			cleft = gcolumn_width;
            lbpos = line_buffer;
		}
	} while ((word = wgetword(NULL, gcolumn_width)) != NULL);
	}
    if (cwords > 0) {    
        wprint_line(cwords, 0, words_list);
        clines++;
    }
	wprintf(L"column width %d, total %d lines\n", gcolumn_width, clines);
}

// main
int main(int argc, char **argv) {
	wchar_t *wcsbuf;
	int iopt;
	size_t maxchr;
	
	if (argc > 1) {
		iopt = (argc==2)?0:2;
		gcolumn_width = (iopt)?atoi(argv[iopt]):60;
		setlocale(LC_ALL, "de_DE.utf8");
		
		if (fwide(stdout,1) >= 0) {
            maxchr = strlen(argv[1])+1;
			if ((wcsbuf = (wchar_t *)malloc(maxchr * sizeof(wchar_t))) != NULL) {
				if (mbstowcs(wcsbuf, argv[1], maxchr) > 0)
					wformat_text(wcsbuf);
				free(wcsbuf);
			}
		}
		else
			printf("stdout is byte oriented.\n");
	}
	return 0;
}