* core/number.c: the `step` method.

 * doc/start.textile: listing some patterns in the code.

 * core/pn-scan.rl: working on better error messages for missing tokens.

Merge branch 'master' of orleans.hobix.com:~/git/potion

 * core/compile.c: fixing method queries.

 * Makefile: fix warnings on 32-bit freebsd.

 * core/pn-gram.y: assignment math combo operations.

 * test/classes/monkey.pn: illustrate placing a value in the method table.

 * test/classes/monkey.pn: how to override core classes, which isn't strictly banned.

 * core/potion.c: fix the repl to handle syntax errors okay.
 * core/pn-scan.rl: bug in reporting character number on the first line.
 * core/objmodel.c: the `exit` method.

 * core/pn-scan.rl: show an excerpt of error-causing code. identifying non-UTF8 characters in syntax errors.

 * core/pn-scan.rl: working on getting some readable syntax errors.

 * README: updating the feature list, correcting some things.

 * core/vm.c: allow potion_vm_proto to unpack arguments properly.

 * core/number.c: the `times` method.

 * core/compile.c: basic block arguments.

 * doc: the short potion pamphlet.

 * core/file.c: a tiny `read` method wrapping fgets.
 * core/potion.c: and a tiny repl to go with it. (doesn't keep track of locals yet.)

 * core/primitive.c: casting booleans and nil to numbers.

 * core/compile.c: merging code for `loop` and `while`.
 * core/vm-x86.c: fixing backwards jumps.

 * example/fannkuch.pn: using callset.

 * core/vm-x86.c: unneeded mov of the counter arg in call op.

 * core/vm-x86.c: support for callset in the jit.

 * test/objects: test of callset.

 * core: callset op. (such as: ary (0) = x)

 * example: speedier gc benchmarks using classes.

 * core/objmodel.c: place object in the write barrier if an ivar is updated.

 * core/compile.c: place `self` before any call to `class`, to clear the first register.

 * core/compile.c: bug in compilation of the upval/local attachments to each proto.

 * core/vm-x86.c: the closure is already available on the stack, no need to use register 1.

 * core/gc.c: track the type catalog and use the write barrier for type changes.

 * core/gc.c: mark type constructors.

 * core/vm-x86.c: support for DEF op in the jit.

 * core/vm-x86.c: get the type jumps right for CALL op. nix superfluous X86_PRE macros.

 * core/vm-x86.c: use rcx for loading of 32-bit argument slots, since most of the other jit code uses rax or rdx.

 * core/vm-x86.c: calling of the constructor during OP_CALL in the jit.

 * core/vm-x86.c: jit'd class op.

 * core/vm-x86.c: code for jit'd GETPATH and SETPATH.

 * core/vm.c: uniting the bytecode layout for table and path ops.

 * core: stubbing out OP_DEF in the jit.

 * test/classes/def.pn: test of defining methods.

 * core: adding OP_DEF for defining methods.

 * core/compile.c: let all constructors return self.

 * test/classes/sub.pn: unbelievable.

 * core/string.c: must use malloc for potion_str2, since modifying the string... well sometimes that string is going to be stored in the strings table and the hashes could be close.

 * core/compile.c: compile initializer properly.

 * core/objmodel.c: the `about` method.

 * core: calling of object constructors in the vm.

 * core/objmodel.c: store constructor in the type.

 * core: working on inheritance.

 * core/compile.c: working on GETPATH and SETPATH ops.

 * core/compile.c: beginning compilation into the CLASS op.

 * core/opcodes.h: added CLASS op.
 * core/internal.c: potion_class function.

 * core/vm-x86.c: move ivar lookup table compiler into platform file.

 * core/objmodel.c: fix jmp in the ivar lookup for 32-bit.

 * core/objmodel.c: working on assembled version of the ivar lookup. straight-forward jumping is simpler/faster than the binary search.

 * core/gc.h: suppress remaining warnings.

 * core/objmodel.c: beginning work on instance variables. using a list of instance variable names, sorted by PNUniq id.

 * core: some new table and inspection functions.

 * core/table.c: including insertion sort and binary search for tuples, which will be used in the instance variable list on each class.

 * example/binarytrees.pn: larger test of allocator, taken from the shootout.
 * core/pn-scan.rl: fixing tab escape.

 * example/gcbench.pn: print description for each allocation stage.

 * core/gc.c: type size for bignums.

 * core/vm-x86.c: fix for 32-bit LOADK op. (Potion *) must be the first argument to any call, due to potion_x86_c_arg.

 * core/vm-x86.c: X86_MOVL is factored out, no static pointers any more.

 * core/vm-x86.c: allocate new closure during the PROTO op.

 * example/gcbench.pn: a translation of test/api/gc-bench.c into potion syntax.

 * core/vm-x86.c: bug in LOADK op. since gc may move around a compiled routine's list of values (strings), the list must be looked up dynamically, using the closure value stored in the (Potion, cl, self) registers.

 * core/vm-x86.c: bug in placing upvals in the PNClosure struct during OP_PROTO call.

 * core/gc.c: mark the various kinds of tables in circulation.
 * core/potion.h: allow protected memory region to be placed in the write barrier.

 * core: place tables in the write barrier any time they're altered.

 * core/gc.c: scan the protected memory space, including the main state struct and the string table during the major phase.

 * core/string.c: no need to store pairs in the string table.

 * core/string.c: switching main string table to store PN as key, allowing gc to move it around.

 * core/potion.h: 32-bit ints hash as themselves. this is lame, i'd like to see nice distribution on all objects, even though strings are the most common to hash.

 * core: trying out a change of object hashing. got this idea from steve dekorte's blog. <dekorte.com/blog/blog.cgi?do=item&id=4003> mostly i'm just trying to hold off from writing hash functions for every individual class type. it incurs a 4 byte hit per object on 32-bit, so i'm not sure if it's permanent yet.

 * core/mt19937ar.c: including mersenne twister.

 * core/potion.h: fixing up all boolean tests to accept nil as false.
 * core/vm-x86.c: ditto (for the TEST, NOT, TESTJMP and NOTJMP ops.)

 * core/lick.c: add `string` method to licks.

 * core/lick.c: adding attributes to the lick-style data.

 * test/data/html.pn: nil at end, since it's all `print` calls right now.

 * core/lick.c: methods `licks` and `text`.
 * test/data/html.pn: test of using lick to build html.

 * core: lick.

 * test/closures/named.pn: test of named method args.

 * core/compile.c: fix message/variable lookup. if a message name occurs past the beginning of an expression, it's not a variable.

 * core/compile.c: working on named args for method calls.
 * core/vm.c: rearranging the OP_CALL register to order to match the layout of PN_F. (PN cl, PN self, ...)

 * core/gc.c: fix potion_type_size for plain PNObject types.

 * test/api/gc-test.c: fix GC tests to use updated api.

 * core/vm-x86.c: 32-bit fix for named arguments in the jit.

 * core: added NAMED operation for assigning a named argument, before a CALL. also, potion_sig_find for determining the order of named arguments.

 * core/compile.c: i want macros gone in the compiler.

 * core/table.c: an `each` method for lists.

 * core: beginning to add instance variables to classes. working the gc benchmark around it.

 * Makefile: move the gc benchmark into `make bench`.
 * test/api/gc-bench.c: no tests in the benchmark and use the same output as the boehm GCBench.

 * core: starting work on method signatures.

 * test/closures/upvals.pn: test use of setlocal with non-upvals.

 * INTERNALS: summary of the garbage collector.

 * core: removing use of PN_FWEAK. it's an optimization that's rare and complicates the stack scanner and the VM. anyway, turns out the JIT code is slightly simplified this route.

 * core/vm-x86.c: store upvals with the PN_FWEAK flag, like in the bytecode vm.

 * core/gc.c: ack, finished the job on the segfault from last commit.