mjhjmtu

Is there a standard way to reverse the output order of a terminal output, ie:

~/Developer $ command0 
-bash: comman0: command not found 
~/Developer $ command2 
-bash: command2: command not found 
~/Developer $ command3 
-bash: command3: command not found 
~/Developer $ 

would be displayed as:

~/Developer $ 
-bash: command3: command not found 
~/Developer $ command3 
-bash: command2: command not found 
~/Developer $ command2 
-bash: comman0: command not found 
~/Developer $ comman0

I feel always having your prompt at the bottom is counter intuitive a more effective way of presenting the output woud be to reverse the output order. How might I go about implementing this? Specifically where output portion of the OSX terminal program defined?

In bash this will display the current prompt/command at the top, and its output below, but with no scrolling or previous commands:

PROMPT_COMMAND='tput cup 0 0; tput el; tput el1'

This function will put previous commands below, but you have to pipe each and every command to it individually. Unfortunately, exec > >(f) can't help with this as it redirects the whole of bash, not individual commands. Here's the function:

f () xargs expr 1 + 

Then run every command like:

command args |f

It saves the output, creates a number of blank lines equal to length+1, then puts the output back in. You can tag a line on at the end that will display a fake prompt or horizontal rule if you like. E.g.

printf '%*s' $COLUMNS | tr ' ' _;

As a crap but automatic alternative to this whole function thing, we can add a command to the end of our earlier $PROMPT_COMMAND that clears a somewhat arbitrary 11 lines:

PROMPT_COMMAND='tput cup 0 0; tput el; tput el1; tput il 11'

You can also use tput -S to avoid multiple binary calls.

I got the $PROMPT_COMMAND from https://github.com/swirepe/alwaysontop .

Unfortunately, this will be fairly difficult. The protocol between the applications and the OS-X terminal is a variant of the VT100 / ANSI terminal control protocol, specifically the XTerm protocol.

That includes a bunch of assumptions about screen position, etc, that would be challenging to remap to a world where the display was reversed.

Even worse, all your terminal emulator gets is a string of "put this character at this position" type commands. There is no distinction made between the command prompt and the output of a command run by it, so you can't do one thing for both parts - at least, not without cooperation from the shell underneath.

The shell, and the programs, assume that the screen proceeds upwards - new data at the bottom, and carries on downward forever.

You could, at least theoretically, have your terminal emulator modified so that it displayed lines in reverse order - the "bottom" line first, and so on up to the "top" line at the bottom of the screen.

That would reverse the order of lines in command output, though, so the rest of the content would pop out backwards too. If you wanted the commands (eg: ls, cat) to run "down" but prompts to move "up" life is harder.

I don't know any software that implements this. (...but see JdeBD's comment to this for a link to one.) :)

Although this won't exactly reverse output, it will keep your prompt at the top:

https://github.com/swirepe/alwaysontop

To use it run:

git clone https://github.com/swirepe/alwaysontop.git
cd alwaysontop/
source alwaysontop.sh

If you decide you like it just source it in your .bash_profile with something like:

echo "source ~/alwaysontop/alwaysontop.sh" >> ~/.bash_profile

Hope that helps!