tree 2c159ba397c0b675323277f7954989aa9c7c49e4
parent 24810426519a002749016cbb04e6c21cd2d890cb
author Robert Karl <robertkarljr@gmail.com> 1482798156 -0800
committer Laslo Hunhold <dev@frign.de> 1482847335 +0100

paste: fix warning on indentation in parallel()

_Bug_
Got the following error after cloning and running make:

paste.c: In function ‘parallel’:
paste.c:70:4: warning: this ‘else’ clause does not guard... [-Wmisleading-indentation]
    else
    ^~~~
paste.c:72:5: note: ...this statement, but the latter is misleadingly indented as if it is guarded by the ‘else’
     last++;
     ^~~~
This patch preserves the same functionality and just adjusts indentation to squelch the warning.

_Test plan_
Used the following 'script' to convince myself output looked correct for inputs
where the latter arguments to paste had fewer lines.

	make && printf "1\n2\n" > two.txt && printf "" > zero.txt && ./paste -d, two.txt zero.txt
