I had more ambitious goals, but I backed out of it: not worth it.
This small optimization is an easy picking though.

find is the biggest chunk of logic of the boot code. The 8086 version
is significantly terser than the z80 one. REP/CMPS helps...

Not comparing strings yet. Without asm tooling support, it's a big
chunk to swallow at once. It's progressing well!

Inline it in next and make chkPS, call a newly reserved label for
it directly, removing a layer of indirection. This frees a spot in
the stable ABI.

I'm not sure yet where I'm going, but I'm not going to build the
8086 port from the ground up like I did with the z80, that is,
making is sustain itself and eventually merge its forth code with
core words. That would be too much work which would then be thrown
out (all those words I'll initially have to implement in asm which
are already implemented in Forth).

What I *think* I can do is build a mirror version of z80 boot code
and cross-compile it from the z80. This means it has to follow z80
stable ABI.

Nope, I'm not sure where I'm going...

Unless I misunderstood, this is supposed to set CS. This would make
all SREG have the same value. This allows us to remove BIN( offset
from os.bin.

I've tried booting to offset 0, but it didn't seem to work. Let's
settle for 0x8000. 512kb of system RAM is way more than we need
anyways.

MBR code now strictly loads OS code into memory and jumps into it.

Now, I've got to consolidate my assembler code, modrm logic is
messed up.

Verified against nasm with equivalent code.

Written from VE!

Otherwise, when editing a file with VE, we would constantly write
to disk, which is a bit inefficient.

This gives us backspace handling. Also, remove all usages of C<
which allows us to remove the C<* override.

It's a quite useful word and it doesn't make sense to reload it from
disk after each usage.

This is the first commit I do entirely in VE. It's a habit I'm planning
on taking as it helps a lot to find usability issues.

When reaching the end of the buffer when typing in IBUF or FBUF, stop
typing instead of overflowing.

There wasn't much of a reason to leave a loop early on 0x0d or null.
The idea was that once you have a CR or null, the rest is garbage
and you shouldn't see it.

However, it brought a problem: In VE, you couldn't insert characters
past that limit. It would be written, but never displayed. So let's
get rid of this logic and simply always display a 64x16 grid.

It simplifies things. Also, removed ';' which became useless.

This allows cut&paste similar to VI's

Make F search from curpos+1 so that it's possible to search the
same word we've just found a second time. Previously, it would find
the word under the cursor.

Also, improve docs a bit.

Previously, it would keep the old buffer displayed why typing over
it. I had kept it thus because I didn't want to erase the buffer
right away because the behavior is that when we type nothing, we
keep the buffer as-is and repeat the action.

Now, the behavior of I and F is much better. It keeps the buffer
displayed until the first non-return keystroke and then erases it.

Also, fixed PSP leak in _type and fixed PSP overuse in successful
_F (they balanced out).

This fixes weird glitches I had on trs80. It's *always* a matter of
RAM initialization. By now, I should know...

Also, I've run VE on the TRS-80 for the first time! It doesn't work
well though. Screen is mostly blank all the time.

I removed instructions from the recipe which became obsolete when
Collapse OS became 100% bootstrapped. Also, I've updated instructions
to change the NL override which is necessary for blkup to work.

Kinda proud of this one. Efficiently piggy-backing on the Block
Editor, keeping things simple, and yet, building power into the
editor.

Which are end-of-word movements.