* stdio:printf("%lt",{term},_):  If term contains a character array,
it should test it to see if it is a printable character array before
printing it.  If it is, then print it as a string.  If it is not,
then print it as an array of integers.

* The try() instruction now uses an offset from the beginning of the
code section, in cells.  During the scan of the code, the linker
should convert these into actual addresses.

* The run() instruction is now expecting just two arguments:
	R1 = tuple containing:
		{Procedure_Name, Arg1, ..., ArgN}
		{{":",Module_Name,Procedure_Name}, Arg1, ..., ArgN}
	R2 = variable to define when procedure has completed

* The put_data() instruction now just stores an offset into the
double, strings, or ints table.  These tables just hold string
representations of the data.

* The compiler should just keep string representations for doubles,
because that is what the assembler stores in the pcno file.  The
tokenizer should just use a {"double","<double_string>"} to represent
a double.  The reason for this is that roundoff error could occur in
the several translations between double and strings.  It is ok to have
the compiler uses integers and strings, because these translate
unambiguously to and from strings.

* Can't have separate intra- and inter-module call tables, because the
linker won't be able to tell the difference when scanning the code.

* Need to add -metacalls() directive to the compiler.

* Add support for exit(exit_code).  This should just pass through to
the encoder as an exit(exit_code) instruction.  When a node executes
this, then it generates an exit message to the host and then waits to
be shut down (possibly handling messages in the mean time).  When the
host node receieves an exit message from a node, or executes the exit
instruction, then it shuts down all of the nodes.

* PCN needs a way to spawn off a server without the synchronization
variables being linked through.  One
link_files:link_procedure_section() is getting left around for each
procedure, because it is having to wait for the merger to terminate,
which won't happen until the entire program is done.  I would like to
be able to detach a process (such as the merger), to run
simultaneously, but have the calling block think it has terminated
immediately.

I can see several ways of doing this:
  1) annotate the call so that the compiler does not string the sync
variables through it, or
  2) have a special detach_server() operator which can be called from
within the server to bind the right sync variable immediately, or
  3) have a directive (-server("proc_name")) which tells the compiler
to treat the procedure specially, by defining its right sync variable
immediately

I think I like method #3.  

* In emulate.c, build_dynamic overflow error message needs the module
and procedure name.

Maybe implementing barriers properly (counting barriers in the
emulator) will solve this problem...

* Changed the order of arguments to I_RECURSE and I_CALL_FOREIGN.  
This was done so that when linking a non-profile executable, the
guage counter and timer arguments can just be left off the end
of the instruction without having to change the emulator code
to deal with differing locations of the other argument.
        I_RECURSE: /* {opcode, arity, _, _}, pcall_index, counter */
   I_CALL_FOREIGN: /* {opcode, args, _, _}, fcall_index, timer */

* Put a hack in link_proc:perform_proc_lookups().  The compiler was
generating the wrong thing when calling wrapper procedures
({"mod","proc._0"} instead of {"","proc._0"})).  So I have the proc
handler test the module name against its own, and if its the same then
do a local lookup.  This is bad because it means that module names
cannot be changed -- intra-module calls use the local module's name
instead of a relative name such as "".

* sprintf should not exit() on BUFF_OVERFLOW.  If there are more
arguments in the tuple than there are specified in the format string,
then it may generate a BUFF_OVERFLOW.

* The following program hangs the compiler with a "should not be here"
message.  It is due to the print(t, argc, argv).
	-exports("main")
	main(argc, argv)
	{||
	    print(argc, argv)
	}



