* test/flow/except.pn: use safe `to` syntax until i decide how to remedy.

 * tools/compile.c: parser tool fix. memory corruption due to an inflexible buffer.

 * tools/greg: suppress warning about unused 'sig', since it's a parse_from rule.

 * core: rename pn-ast.c to ast.c and so on, since the parser has shrunk and the pn- prefix has gone away.

 * core/table.c: fix Tuple(put) to allow negative numbers or pushing onto the end of the array.
 * core/potion.c: avoid use of the multiline ending, since it hasn't been introduced yet in the new parser.

 * doc: adding a description of lick unquoted values and updating the numbers section.

 * core/syntax.g: reset P->source after every parse.

 * core/string.c: expand byte buffers a bit extra in advance, to avoid so much reallocation.

 * core/syntax.g: no need to alloc PNAsm buffer for potion_sig.

 * core/syntax.g: merging sig.g here. updating to use reentrant code. still need to get all parser structs stored in gc.

 * test: mark some tests as broken that have outdated syntax.
 * core/syntax.g: allow braces and parens to start on a newline.

 * Makefile: bsd rule for .g -> .c.

 * core/sig.g: grammar for method signatures in C.

 * core: removing ragel and lemon, switching exclusively to peg/leg.

 * core/syntax.g: improve nesting of brackets and parens within unquoted licks.

 * core/syntax.g: make assignment and prefix operators right-recursive. fix logic operators.

 * core/syntax.g: operator precedence. path fixes.

 * core/syntax.g: fix number-related parsings.
 * test/numbers/neg.pn: parser isn't going to allow multiple prefix operators for now.

 * core/syntax.g: escape codes in strings. newlines swallowed after non-terminal characters.

 * core: working to consolidate PNAsm and PNBytes into a single structure.

 * tools/: add reentrant peg/leg.

 * core/syntax.g: tuple building problems.
 * core/potion.c: -G flag for using the new parser.

 * core/syntax.g: method calls and unquoted licks.

 * core/syntax.g: a lot of operators, assignment, keyed tables.

 * core/syntax.g: beginning a new parser using a reentrant, hacked peg/leg.

 * core/vm-x86.c: optimizing addition, subtration, multiplication and bit negation.

 * test/api/potion-test.c: broken eval test. needed to pass closure in as the second arg.

 * core/compile.c: fixing `make JIT=0`.

 * test/flow/except.pn: evidence that the counter is incrementing.

 * core/vm-x86.c: pad the stack 8 bytes on 32-bit, since the `self` slot is getting clobbered.

 * core/callcc.c: eliminating use of a register, some 32-bit platforms don't have so many GENERAL_REGS.

 * test/classes/creature.pn: another test of subclasses and methods.

 * core/gc.c: deleting strings from the table that have fallen out of use.

 * core: allow safe compilation on non-x86, although continuations and jit will not function for now.

 * core: object inspection methods may use byte strings within, but ultimately return UTF-8 strings.

 * core/callcc.c: bug in continuations. needed to send back `self` rather than `cl` from the yield.
 * test: a few tests of continuations.

 * core/callcc.c: remaining callee-saved registers on 64-bit. cool, bytecode vm is working!

 * core/callcc.c: place callee-saved registers in the continuation.

 * test/flow/callcc.pn: remove the test until it works with the bytecode vm.

 * core/table.c: `push` and `append` for lists.
 * core/objmodel.c: renamed `callcc` to `here`.

 * core: simplifying the forwarding of P->strings and vt->methods lookup tables. anyway, bug in reallocation of vt->methods, needed to be touched.

 * core/callcc.c: unused variable `n`.

 * test: changing some test numbers with precision problems while floats are in effect.

 * core/gc.c: keep continuations constantly in the write barrier, since their contents can change without notice.

 * core/gc.c: continuations are scanned just like the normal stack.
 * core/callcc.c: giving continuations their own class.

 * core/pn-scan.rl: comments eat ending newlines.

 * core/callcc.c: had the 64-bit #if conditional wrong. eliminated use of %4 in the asm.

 * core/callcc.c: continuations for 32-bit.

 * core/callcc.c: return the continuation from `yield`, to be sure it is stored in the variable again.
 * core/table.c: `pop` method for lists.

 * core/callcc.c: working on improving the callcc code to honor stack direction.

 * core/string.c: fwd byte strings before converting to intern'd strings.

 * core/vm-x86.c: fix 4+ argument functions on x86_64.
 * test/closures/long.pn: test of 14 arguments (the present limit.)

 * core/string.c: put state in the write barrier if the string table moves.

 * core/string.c: Bytes `string` method converts to a UTF-8 string.
 * core/vm-x86.c: fix for callset op.

 * core/vm.c: the bytecode vm math is now equivalent to the jit's math.
 * core/number.c: simplifying potion_decimal.

 * core/number.c: eliminating arprec code to focus on a double-based struct. may switch to _Decimal64 after some benchmarking. and then will remerge the arprec stuff.

 * core/number.c: importing more arprec math.

 * core: beginning a little decimal representation based on arprec. <crd.lbl.gov/~dhbailey/mpdist/>

 * core/vm-x86.c: trimming down the ADD and SUB ops by switching edx and eax.

 * core/gc.c: first phase should be a minor phase. allocate a rough old area first and then kick it off.

 * example/recursive.pn: an (old?) shootout example testing recursion. need to do floats.

 * core: added WAVY bitwise negation operator.

 * core: finessing the compiler to do normal binding in the case of no arguments present. previous checkin had problems with optional arguments.

 * core: when calling messages, allow immediate dispatch if the message receives no arguments. (avoiding use of: table () ('key') syntax)

 * core/vm-x86.c: removing the jit's inline cache, the code is so irrelevant i'll need to start over.

 * core/gc.h: small scripts don't need megs. estimate a good birth size based on amount needed and size of the older gen.

 * core/pn-scan.rl: fix for table-only lick nodes.

 * core/pn-scan.rl: allowing flexible unquoted strings in licks.
 * test/data/grammar.pn: rough sketch of a peg-style grammar done in unquoted strings.

 * core/compile.c: empty closures and tables bug. thanks, @henkboom!

 * core: eliminating the inline method cache from C. i'll get back to this once methods can be stored in a fixed memory area.

 * core/file.c: load environment variables in the Env table.

 * core/vm-x86.c: fix for LOADK op in the jit. problems reaching beyond 10 or so entries in the `values` array.

 * core/khash.h: the last malloc departs.

 * core/pn-gram.y: allow a newline or separator before a square bracket.

 * core/pn-scan.rl: passing syntax errors through an Error object.
 * core/potion.c: print errors from the interactive mode and script run.

 * core/string.c: another malloc gone. added potion_str_format for building strings from c using printf's syntax.

 * core/string.c: fixing the `at` method to use `slice`. a bug when using strings as functions.

 * core/gc.c: two bugs found in the new table code. first, hashes weren't being checked for forwarding pointers in the gc. second, the string table wasn't being updated with its new pointer. with these changes in place, my rigorous test of table allocation is passing.
 * example/gcbench-table.pn: a test of allocation a few hundred megs of tables.

 * core: hi, everybody. this work i'm checking in surrounds the representation of hash tables in memory. i'm trying to squeeze down the size they take up. potion has three different types of hash tables: the basic table, the method table, and the strings table. this is the last object structure to be moved into gc (there are only two small malloc calls left in Potion.) previously, a basic hash table would take up 48 bytes of overhead on 64-bit. in addition, the table object was split into two parts: the immutable table object and a mutable table array. with this code, the table overhead is 24 bytes and the objects are combined. this means every table object is mutable and will move about in memory (like lists already do.) the total cost of a hashtable is now: 24 bytes + 4 bytes for every 16 pairs + each pair (8 bytes * 2). for comparison, a list is 16 bytes + each item (8 bytes).

 * core/vm-x86.c: incorrect jump on x86.

 * core/khash.h: reworking hashes to keep the pairs in potion's heap.

 * core/objmodel.c: moving the jit mcache into the x86 code.

 * core: stubbed out operator overloading in the jit. anything that isn't an integer goes through method dispatch.

 * doc/start.textile: some notes on paths, conditionals.

 * doc/start.textile: a note about whitespace.

 * core/number.c: the `times` and `to` methods return how many times they ran the block.
 * core/string.c: broken PN_ATOI call.

 * core/compile.c: a ?query call should return nil if no message is found.

 * core/pn-scan.rl: parsing hex numbers. changing the single quote escape char to ''.  allowing space after the question mark in a query call.
 * doc/start.textile: beginning the section on syntax details.

 * core: retrieve the ast for a closure using `cl code tree`. still need to work on methods for modifying and re-compiling.

 * core/objmodel.c: store function signatures with the closure, display the signature on Function#string.

 * core/compile.c: allow values to be called directly as functions.

 * test/numbers/to.pn: test variable use.

 * core/pn-gram.y: an awkward way of doing mixed block/args.
 * core/number.c: the `to` method.

 * core/vm-x86.c: further jump fixes on 32-bit.

 * core/vm-x86.c: fixing up new jumps in the call op.

 * core/table.c: the `first` and `last` methods.
 * test/tutorial: all examples from the pamphlet.

 * core: restructure call and callset to allow keyword args.

 * doc/doc.css: text colors.

 * doc/start.textile: fixing license spacing.

 * doc/start.textile: breaking up the pamphlet with titles.