minor cleanup

dup

minor cleanup

truthy

Definitions.

There are things to like about this implementation and things to
dislike.

Things to like:

- It works.
- The defs are baked into the wordlist.

Cons:

- The def bodies are built at start time by parsing strings.  it would
  be nice to somehow generate initializer literals if possible.  But
  would that mess up the garbage collector?
- It requires manual labor to update the defs when defs.txt changes.  It
  would be nice to have a solution that *make* can use.

A first attempt at definitions.

Almost truthy...

div and mod

clear

branch combinator.

i combinator.

Depend on joy.h.

Minor cleanup, print_stack.

Minor cleanup.

Expression is a list-of-lists now.

That way we don't have to concatinate quotes onto it all the time.
Instead we amortize in the next_term() function.

Cmp, comes with GMP.

Boolean singleton values.

Boolean singleton values.

Node head is pointer now.

JoyListPtr too

Use JoyListPtr.

sub and mul through judicious (I hope) use of macros.

pop_any(), pop_int(), and add

Interpret symbols.

C has function pointers, we can put them in the Gperf wordlist, this
makes the interpreter really simple.  No need for a dictionary (yet).

Implementing the basis functions will be a bit of a slog, and
I still have to implement definitions, but this is starting to shape up
nicely.

Yet more minor cleanup.

More minor cleanup.

Minor cleanup.

newJoyList

Can haz function pointers in my worldist.

typedef for the win!

make clean rule

Use gperf to save memory.

We check terms to see if they're in the wordlist, if they are we reuse
the string from the wordlist instead of allocating a new one.

(I've always wanted to use Gperf so I'm pretty stoked about this!)

Ignore object files.

minor cleanup

Gperf.

Minor cleanup.

True and False values.

Copyright, etc.

Fix bug with no trailing spaces.

Gotta update that pointer, eh?

I was post-incrementing when I should have been pre-incrementing!

D'oh!

Simple terms work. Problem is with sub-lists.

Parsing isn't this hard?

Um, don't do that.

I wonder where the data was winding up?

Minor cleanup.

Remove separate parser code.

Print true, false, and lists.

Print ints.

Print list.

Text to expr coming along.

Need to be able to store a string.

Minor cleanup.

Minor cleanup.

Don't pass NULL to strpbrk().

Handle stretches of blanks.

Don't create zero-length strings.

Nice skeleton of parser.

Almost there on parsing.

trim_leading_blanks

Let's parse.

Don't version the binary.

I think I'm doing this right?

minor style glitch

Minor cleanup.

Some notebooks.

Messing around with C.

Readline support would be nice.

This and that.

Cleanup and refactoring.

Bug when subtracting identical numbers.  It gives

    [false 0]

When it should be

    [false]

or better yet

    [true]

eh?

That seems to work: addition and subtraction.

Mostly done with addition and subtraction.

Not quite as smooth as I'd hoped.

Subtraction seems to work now.

Progress.

Adding like-sign bigints in Joy.

Misc stuff.

Minor cleanup.

Add two lists of digits.

I think I got it.

Whew!  Think slow and steady FTW.  Don't get ahead of yourself.  Put the
non-recursive parts in the non-recursive branch, duh.

Dang it...

Minor cleanup.

Just for me...

(That's how you look all clever, but it's a dick move removing the
commentary like that.)

Bisect for the win!

find_greatest()

I think it's ready to use...

Finish lil_divmod.

One more lil bug squash.

Subsidiary functions...

Fuzz FTW.

Div Mod of same sign ints.

That seems to be that.

Flush out and squash some bugs.

I think I figured something out...

Kinda sorta not really working,

as in broken.

This is getting out of hand.

Almost got it...

Divmod, yeah?

Minor cleanup.

I almost can't believe I did it.  I guess I thought it would be harder
or more involved.  Maybe divmod will be a pill?

Kinda relaxing after wasting the weekend nerd-sniped by curses.

Copyright and executable bit

Minor cleanup.

Minor cleanup; multiplication.

I forgot to commit after cleanup but before implementing multiplication
so this commit is kind of a mess.

Anyway, it works.  :D

test_Subtraction_large_from_small

I guess subtraction works!?

Adding two negative numbers.

That was easy!  Add BigInts of the same sign.

Red... (Green, Refactor)

TDD FTW!

Not using ctypes; test_twice_min

Minor cleanup.