Merge branch 'master' of github.com:pete/pez

Attempt to make that memory contiguous.

It speeds things up, but not as much as I'd hoped.

Add a bug to TODO.

Merge pull request #4 from larsbrinkhoff/master

Make GitHub detect *.pez as Forth

Make GitHub detect *.pez as Forth

I love getting to delete m4 files!

Lightning isn'used any more.

There is not much to this, but it is a small library for fractions.

Poke at write and gets a little.  Need sighandlers.

Fix the the spell checker example to use the new FFI.

Seems lib/prime-sieve.pez had been "staged" but not "committed" for months. GIT!

New words:  pipe, fddup, fddup2.  Wrappers around pipe(2), dup(2), dup2(2).

TODO is a file which will never be zero lines long.

Put Wolf in the credits, that guy is awesome.

A couple of minor error-handling fixes, and make bounds-checking the default.

General cleanup; fix a couple of undefined behaviors and make bounds checking
something you turn off instead of on.
(Incidentally, the overhead for bounds-checking is insanely small for most
of the code I've tested.  Might just leave it always on.)

Reformat comments, and don't be an idiot around pointers.

Redo TODO

Take the puts() out, baller style.

Here I was, worried that adding libtcc to the autotools mess would be a
pain.  It was not...yet.

Dropping Lightning from the FFI in favor of libtcc.

Incorrectly checked overflow rather than underflow.

Prefetching IP.  This is experimental!  Eliminating the pointer-chasing speeds
a lot of operations up by 10-30%, but slows some down (mainly pushing literals)
due to (I suspect without being certain) branch-predictor misses.  Getting those
back up to speed involves a reworking of (LIT).  My intention is to do one of
these:  re-add the (LIT0), (LIT1), etc., words from the old branch; use
lightning to generate (LITx) words as needed; tag literals and only resort to
use of (LIT) when we need all N bits of a cell; revert this patch.  Still not
quite certain.

New word:  w_nohang, flag for wait.

New word:  rdrop

Eliminate branches for comparisons.  Pfffft.

New word:  'times', ( word n -- ).  It takes a word and a number of times to execute the word.

I wanted some math.

Add a couple of float stack manipulators, make 'clear' clear both stacks,
and reorder/trim the interpreter struct.  Believe it or not, this made Pez
faster by about 5%.

New word:  log10.  Toyed with calling it log[10], wisely chickened out.

The C preprocessor told me that it was disappoint.

Done having build issues with what was already a bad idea.

Moved to the dispenser repo.

New word:  die (like die!, but no message).  Fix a bug in waitpid.

BLOOPSAPHONE!

There was a bug in the handling of floats/doubles when loading/storing explicit
C types.  Discovered while writing an interface for _why's bloopsaphone (for
epic justice; it'll be checked in when it definitely works).

That changed a long time ago.

Gone.

And AWIB ( code.google.com/p/awib/ ) actually won't run without more
cells.

And this is the solution that should have occurred to me *first*.

That's the dumb but less hacky version.  Next up...

speling.pez, an implementation of Norvig's spelling corrector.

Very simple benchmarking lib.

Fix a bug in 'execute', document exword() (so as to avoid this bug in the
future), and then a few other comment tweaks.

Drop a bug from read-file in core.pez.

I needed one of these.

strform was lying!

If you check the date I added that TODO, you'll see how long this has been
bothering me.

Floats get their own stack.
Advantages:
  * Faster
  * Cleaner (much less alignment special-casing)
  * Simpler (especially for the FFI)

This left a pointer to the library name on the stack.  This would actually be
and accidental feature, were it not for the fact that popping it off would
cause the else clause to do bad stuff to memory.

Minor additions to the core library.

New word:  ht-values.  Yes, I copypasta'd.

Two new words:  ht-size and ht-keys, to get the size and an array of the keys
out of a hash table, respectively.

Unnecessary output.
(I was doing diffs against prime lists generated by another program
to verify; the "[pez]" was there to make them easier to read.)

Dang but reverse Polish notation seems to have made me reason backwards.

Why did I have the word "pile" in there?

Adding a prime number sieve example.

These are going away, actually, and moving elsewhere.  Stay tuned.

Whoa, that's a *bug*.

atoi

Left that off until now.

New words:  chomp and chomp!

Keep out the generated file.

Some FFI cleanup.

De-dup that.

New words:  $, waitpid.  "some command line" $ is similar to backticks in other
languages, waitpid is about what you expect.

For FFI stuff to build with the same options as Pez, it needs config.h around.

Whoops!

New word:  fsleep, which takes a float.

Adding the beginnings of the SDL lib.  Currently testing it out, should have
the rest up soon, as well as some helpers for compiling C-FFI stuff.

Stuffing these into the API.  Amazed they weren't there.

New word:  rand.

Stuff all of that into core.pez.

New word:  realloc.  Apparently, uh, reading a few megabytes of data is slow as
hell if you do it by reading 4k chunks and s+'ing them.  Ahem.

A light touch-up for the list concatenator.  It's still O(n)!

Poke at the linked list library, make it use the new struct stuff.

A whitespace change to move a comment immediately above the function it
describes.  Definitely my best commit ever.

That was broken anyway.  It will be back shortly, though.

755

Wow, it feels good to take that out of the TODO.

Add support for structs, at long last!
Also fix sdup and gets, a warning in tuck and 2tuck, and document system.
Non-atomic, but not my only atrocity of the day.

That example segfaulted if no arguments were passed.

Include those files in the build.

This was the stuff I was putting off because it was tedious.  Even generating
it was tedious.  Anyway, this should be all we need to make structs worse.

I had some fun printing prime factors of things.

TODO update.

New words:  tuck, 2tuck, and some tests.

Clean that horror up a little.

Add a thousand annoying size words and accessors for various types, for talking
to C libraries.  Some use standard C types with platform-dependent sizes, some
use types that explicitly mention sizes, and it's just a mess.  No two ways
about it.  (But, thankfully, autotools can shield us from parts of it.)

Three new words:  sdup, ht-dup, format.  Will eventually do fformat.

Update an example.

Laying it out a little more plainly.

AUTOMATIC

Yeah, the flags are a little obscure, still.

TODOne!

Move the zero-branch checking into ; (i.e., at compilation finish) so that
we can avoid the cost of doing it at runtime.  The one caveat is that ; doesn't
always get called (!!) and I don't have a good solution yet, but presumably
you know the risks if you're assembling words yourself or using does>.

Gots to do something about that problem.

Checking for bad branches.

Well, that solves the mystery of the angry floats.

And another.