A first attempt to wrap paragraphs

In the last chapter, we justified text, but only one line at the time. In this chapter, we will try to wrap an entire paragraph to create the lines. Normally, this kind algorithms do not run in PostScript, but we can program it in PostScript.

There are many sophisticated algorithms for this, including the Knuth-Plass line-breaking algorithm that optimize the spaces playing with the knowledge of all lines and using also hyphenation.

We keep it very simple. Our algorithm works like a typewriter. We write each word after another and when we see that the next word does not fit into the line width, we go to the next line.

First, we need some operators. neg negates a number (-1 mul), roll allows to access deeper elements of the stack by rolling the top elements of the stack and newpath explicitly starts a new path.

Javascript Editor

operators.neg = function(context) {
    const [x] = context.pop("number");
    if (!x) return context;
    context.stack.push(new rpnNumber(-x.value));
    return context;
};
unitTest("2 neg", "-2")
unitTest("-2 neg", "2")
unitTest("0 neg", "0")

operators.roll = function(context) {
    const [roll, n] = context.pop("number", "number");
    if (context.stack.length < n.value) {
        return context.error("stackunderflow"); 
    }
    const thisstack = context.stack.slice(context.stack.length - n.value);
    const rootstack = context.stack.slice(0,context.stack.length-n.value);
 
    if (roll.value > 0) {
        for (var i = 0; i < roll.value; i++) {
     thisstack.unshift(thisstack.pop());
 }
    }
    if (roll.value < 0) {
        for (var i = 0; i< -roll.value; i++) {
            thisstack.push(thisstack.shift());
 }
    }
 
    for(var i = 0; i < n.value; i++) context.stack.pop();
    for(var i = 0; i < n.value; i++) context.stack.push(thisstack.shift());
    return context;
};
unitTest("1 2 3 4 3 1 roll", "1 4 2 3")
unitTest("1 2 3 4 3 -1 roll", "1 3 4 2")

operators.newpath = function(context) {
    context.path = [];
    return context;
};