p: show a usable message from Scheme if the subprocess terminates by signals

Give at least *some* hinting about segfaults happening in subprocesses.

Signed-off-by: Christian Jaeger <pflanze@gmx.ch>

Fix bracketig in the transition from / to >>

Unlike the division operator, the shift operator has lower precedence
than the plus operator, so parentheses are necessary.

This manifested itself for example when running tests/test-pairs.hex:
 Program received signal SIGSEGV, Segmentation fault.
 0x0000000000400a46 in ram_set_gc_tags (o=<value optimized out>, tags=0 '\0') at picobit-vm.c:68

Signed-off-by: Christian Jaeger <pflanze@gmx.ch>

Remove sed usage as "p" now strips the suffix by itself

Signed-off-by: Christian Jaeger <pflanze@gmx.ch>

p: replace shell script with Scheme implementation

To avoid requiring a shell and truncate the file path portably.

(And to be able to output a newline after the vm output and still be
able to pass on the vm's exit code. Although adding the newline
somehow doesn't give the intended effect (thus not included in the
patch here), and passing on the exit code portably is not done yet.)

Signed-off-by: Christian Jaeger <pflanze@gmx.ch>

p: use dirname and basename to get the base of the path

Signed-off-by: Christian Jaeger <pflanze@gmx.ch>

p: add a newline after the output

Signed-off-by: Christian Jaeger <pflanze@gmx.ch>

Add README

Signed-off-by: Christian Jaeger <pflanze@gmx.ch>

p: quote variables and die on variable referencing errors

Signed-off-by: Christian Jaeger <pflanze@gmx.ch>

Networking is now an option (compile with -DNETWORKING).
Some int32 were changed to int16.

Other changes to please SIXPIC: (void) -> ()

[pflanze@gmx.ch: split original patch into two separate patches, this
  being the second one]
Signed-off-by: Christian Jaeger <pflanze@gmx.ch>

Changed divisions to shifts, there were only divisions by 2 or 4.

[pflanze@gmx.ch: split original patch into two separate patches, this
  being the first one]
Signed-off-by: Christian Jaeger <pflanze@gmx.ch>

Put some debugging functions in an ifdef, since they are only relevant
on a workstation.

Moved some code around.

Various cleanup.

Split the compiler into several files and repository cleanup.

Added ior and xor tests to the repository.

Added bitwise ior and xor for bignums.

Removed some hard-coded paths, to make release easier.

Added the picobit script to the repository, which should have been
there all along.

Further cleanup and code reorganization.

[pflanze@gmx.ch: moved the following fix from later patch "Networking
  is now an option" to here, so that git bisect could work:
 +#ifdef WORKSTATION
 +char *prim_name[64];
 +#endif
]
Signed-off-by: Christian Jaeger <pflanze@gmx.ch>

Further cleanup and code reorganization.

Cleanup. Split the code into various files.

Tests added to the repository.

New, much simpler, code for bignum encoding has been added to the
compiler. All the tests so far pass, so it seems to be working.
Bignum division and remainder primitives were implemented, which means
display of bignums can work.

Primitive bignum encoding added in the compiler. Doesn't work for all
cases. For now is an ugly iterative kludge. Next step is to put it
into CPS, like the rest of this pass.

Fixed a bug related to negative fixnum encoding (i.e. -1). -1 was
casted to unsigned, and became 255, which was then encoded as fixnum.

Fixed a couple of issues with bignums. Most notably, negative_carry
took a boolean, which has a width of 8, but was given results of a
bitwise and on 16 bits. Now uses the integer type instead of boolean.

Bignums have not been thoroughly tested yet.

Added math.scm to the repository, which contains bignum functions.

Integrated code for bignums. Most of it wasn't checked, though, so it
likely won't work. What's left to do for this is to check the added
code, and to make sure it works. Also, make sure the compiler is
aware, if necessary of these new bignums.

Added networking, improved error messages and various minor changes.

Various cleanup.

Exposed a few type-checking primitives from the library.
General cleanup.

Vector copy now works, or at least, looks like it does.
Rom vectors are back to ordinary lists, much simpler that way.

Work has begun on efficient vector copy.
However, rom vectors as dotted lists end up complicating this, and
will be removed.

We can now have up to 64 primitives. None of the new are used yet, but
vector-copy is next.

Vectors should now be working. All lengths are stored raw, not encoded
as ints.

Vectors are slightly broken, in the middle of fixing them.
Still deciding whether to stored the length of the vector raw or int encoded.

Dummy commit.
Had a problem with the last commit comment.
It should have said that the make-u8vector primitive now sets the
right default values (and takes 2 parameters).

that in the scheme code was much too costly.
Various other corrections.

Rom vectors are now stored as fotted lists, which saves 1 pair per
vector. We'll have to see if the effect on the size of the vm is too
much or not.

Merged most of Etienne's improvements from last year, including
macros, named lets, letrecs, etc.
They seem to work.

Added Etienne's error messages to the vm, which give the name of the
primitive where the error occurred.

Globals are now dynamically allocated, up to 256 of them.
The stack can now theoretically run.

We can now have up to 128 globals. The number is arbitrary, but could
go up to 256, since we have a byte to encode them. For now, their
number is statically determined, which can cause wasted space if not
all are used. We'll change this to be dynamic, the number of globals
will be encoded in the beginning of the bytecode, as is the case with
constants and globals will simply occupy the beginning of ordinary ram.

Short instructions are there, they are coded both in the compiler and
the VM, but they cause segfaults. I'll debug these later since they
are not too important.

Push-long now uses a 4-bit opcode. Reduces size a bit.
Now we have a lot of free opcodes.
I'll try to add some "short" versions to the label instrs, with only 8
bit of address.

Concentrated all the label instructions (call-toplevel, goto, etc)
under a single 4-bit opcode. Now to find a way to use this freed
space. Push long is first in line.

Extended the primitive substitution to binary arithmetic operators.
As long as an arithmetic operation has only 2 operands, the
corresponding primitive is used instead of the wrapper.
Stack down to 5691 bytes.

Added a little optimization. Calls to certain functions can now be
replaced directly by primitive calls y the compiler, saving a
call/return each time. Stack is down to 5805 bytes thanks to that.

Optimized the library a bit by calling primitives directly instead of wrappers.

Literal byte-vectors now end up in rom, as lists, as should be.
Maybe another representation could be better, but for now, that will do.

Byte vectors are now working. They can only be created at runtime yet,
though. Now, let's see what we can do for rom/literal vectors.

Various cleanup.

Code is now cleaner, no more second_half.

GC bug solved. Now new objects should work completely.
Now, I'll get rid of second_half (can be replaced by arg1..4) and
implement true vectors.

Fixnums now go from 0 to 255 instead of -5 to 40. Nothings seems to
have broken because of this, but the GC bug subsists.
Saves us about 200 bytes for the stack (from 5980 to 5808).

New objects mostly work, procedure calls are ok, but GC messes things up.
After a GC, both env and the continuation stack are messed up.
However, the vm now uses all memory, not just 8 bits, so GC happens
only in big programs.

New object representation works partially.
test-globals works without any problem, but still some trouble with red-green.

Integrated modifications for the new PIC.
Changed the compiler with new representation.
Changed the representation of closures and continuations, since we
learned that closures were used as pairs when doing lookup.
Tried to add global to constant conversion in the compiler, but didn't
work. When we fix it, make it work only for globals that contain
numbers, bools and co. No pairs, vectors, etc, so we can only check
for set!s and not set-car!s and co.

GC was changed to consider the new representation.
The compiler still has to be changed.
This is the last version for the old PIC, from now on, the code for
picoboard-v2 will be merged.

Most of the vm has been changed to use the 13-bit representation.
I think only the gc still needs to be changed.
No work has started on the conversion of the compiler. A lot of work
will be needed, since now many instructions take more arguments (bytes
after the opcode) than they used to.

GC seems to work with 12 bits.
Compiler still does not work correctly with 12 bits.
12-bit representation will be abandoned and Marc's 13-bit one will be
used instead. This will require some modifications to the VM (should
not be too hard) and some serious changes to the compiler (which would
need to change anyways since 12 bits don't work).

Partial 12-bit support. VM mostly works (GC is left) but compiler does not.
The GC still needs to be adapted to the new representation, and the
compiler also does, but it would require a lot more work.
We'll also need to store immutable globals as constants, since we have
some constants left and no more globals. Maybe find a way to get rid
of some globals/constants, and do propagation.
For now, the red-green example works, but not much else.

Vectors are now r-a-lists, bitwise operations are there.
All the features needed by PICOBIT are implemented.
Now, we have a problem of address space, as well as constant and
global variable counts.
Next steps : change representation of objets to increase address space
     add vectors as contiguous space

Picobit now has triplets, which can be used to implement
vectors. Actually, 3 implementations of vectors have been written. One
that makes linked lists of triplets, another that used Chris Okasaki's
random access lists (the O(1) list operations are useless here since
we are implementing vectors, which have fixed size) and a last one
that has simple complete binary trees (the code is actually uglier
than the r-a-lists, since we have to build the tree all at once (no
cheap "consing"), and we have to find the smallest size of tree that
fits, which uses an ugly binary search through powers of 2).

Will have to get rid of some of the least useful primitives to make
room for ior and xor, and maybe others.

Initial commit.
Already did some work. u8vector constructor works, it's actually just
a parser hack that generates a string and the parse it. Since strings
are stored as byte vectors, this gives the result we
want. u8vector-ref also works, it's implemented as a library
function. I added a primitive, which ended up being unnecessary, I'll
get rid of it.