accomodate empty type table in 6l.

R=r
DELTA=10  (2 added, 8 deleted, 0 changed)
OCL=18601
CL=18605

- re-enabled bug118.go for pretty

R=r
OCL=18604
CL=18604

always show original name

R=ken
OCL=18603
CL=18603

R=r
OCL=18602
CL=18602

R=r
OCL=18599
CL=18599

R=ken,rsc
DELTA=14  (14 added, 0 deleted, 0 changed)
OCL=18555
CL=18598

R=r
OCL=18580
CL=18582

	package main
	func main() {
		var i interface { } = 1;
		a := i.(*[]byte);
	}

interface { } is int, not *[]uint8
throw: interface conversion

	package main
	func main() {
		var i interface { };
		a := i.(*[]byte);
	}

interface is nil, not *[]uint8
throw: interface conversion

	package main
	func main() {
		i := sys.unreflect(0, "*bogus");
		a := i.(*[]byte);
	}

interface { } is *bogus, not *[]uint8
throw: interface conversion

R=r
DELTA=30  (24 added, 2 deleted, 4 changed)
OCL=18548
CL=18565

R=rsc
DELTA=28  (14 added, 4 deleted, 10 changed)
OCL=18561
CL=18563

recognize methods for a variable whose type is a named type
which is a pointer type.  Add bug117 to test this case.

R=r
DELTA=24  (22 added, 0 deleted, 2 changed)
OCL=18547
CL=18554

	* allow conversion between nil interface and any type.
	* mark signatures as DUPOK so that multiple .6 can
	  contain sigt.*[]byte and only one gets used.

R=ken
OCL=18538
CL=18542

current spec forbids it:
    The type specified by the type name is called ``receiver
    base type''.  The receiver base type must be a type
    declared in the current file, and it must not be a pointer
    type.

R=r
DELTA=2  (0 added, 0 deleted, 2 changed)
OCL=18527
CL=18541

R=rsc
DELTA=4  (1 added, 1 deleted, 2 changed)
OCL=18528
CL=18533

add Value.Interface, to extract an empty interface
that can be converted to a regular Go value of the
appropriate type, if known.

R=rsc
DELTA=49  (2 added, 0 deleted, 47 changed)
OCL=18526
CL=18526

parsed interfaces wrong.
could not handle a function with a single type as a return value.

R=rsc
DELTA=34  (20 added, 2 deleted, 12 changed)
OCL=18511
CL=18520

R=rsc
DELTA=187  (107 added, 28 deleted, 52 changed)
OCL=18510
CL=18510

- decribe passing of "..." parameters for a start

R=r
DELTA=70  (69 added, 0 deleted, 1 changed)
OCL=18503
CL=18503

R=rsc
OCL=18482
CL=18484

R=r
OCL=18475
CL=18475

R=rsc
DELTA=31  (9 added, 6 deleted, 16 changed)
OCL=18470
CL=18472

R=r
DELTA=3501  (1752 added, 1749 deleted, 0 changed)
OCL=18460
CL=18471

- removed trailing tabs

R=r
OCL=18458
CL=18458

R=iant
DELTA=24  (13 added, 10 deleted, 1 changed)
OCL=18424
CL=18439

- completed rational support
- better documentation
- more tests
- cleanups

R=r
OCL=18438
CL=18438

whatever the final syntax ends up being.

R=ken
OCL=18414
CL=18414

add sys.unreflect, which uses gotypesigs.

R=r
DELTA=170  (152 added, 12 deleted, 6 changed)
OCL=18396
CL=18404

R=r
DELTA=51  (0 added, 0 deleted, 51 changed)
OCL=18399
CL=18402

R=rsc
DELTA=5  (1 added, 2 deleted, 2 changed)
OCL=18395
CL=18398

R=r
DELTA=124  (62 added, 62 deleted, 0 changed)
OCL=18389
CL=18394

R=rsc
DELTA=17  (17 added, 0 deleted, 0 changed)
OCL=18386
CL=18393

TBR=r
OCL=18381
CL=18383

	sigi and sigt:
	sys·sigi_inter -> sigi·inter
	sys·sigt_int -> sigt·int
	Package·sigt_Type -> sigt·Package.Type

	local type T in file x.go T_x -> T·x
	second one T_x_1 -> T·x·1

	method names M on T  T_M -> T·M

correctly handle local embedded types

init functions are the only place left that use underscores

R=ken
OCL=18377
CL=18377

only unencapsulated if passing one ddd
argument to one ddd parameter.

R=r
OCL=18376
CL=18376

R=rsc
DELTA=7  (7 added, 0 deleted, 0 changed)
OCL=18372
CL=18372

R=r
OCL=18351
CL=18351

R=ken
OCL=18348
CL=18348

R=rsc
DELTA=60  (35 added, 17 deleted, 8 changed)
OCL=18339
CL=18343

R=r
DELTA=15  (10 added, 3 deleted, 2 changed)
OCL=18334
CL=18336

  (operates on 30bit values at a time instead of 20bit values)
- refactored and cleaned up lots of code
- more tests
- close to check-in as complete library

R=r
OCL=18326
CL=18326

Plus print[ln] with the ability to print struct values.

Note for language mavens: if a "..." function passes its argument
to another "..." function, the argument is not wrapped again.  This
allows printf to call fprintf without extra manipulation. It's good
but needs to go in the spec.

This code works:
///
package main

import fmt "fmt"
import os "os"

type T struct { s string; a, b int }

func main() {
	P := fmt.Printer();
	P.printf("%s = %d with float value %.4f\n", "hi there", 7, 123.456);
	P.println("hi there", 7, 123.456);
	P.fprintf(os.Stdout, "%s = %d with float value %.4f\n", "hi there", 7, 123.456);
	P.println(T{"x", 7, 234}, "end of struct", 8, 9);
}

R=rsc
DELTA=28  (7 added, 3 deleted, 18 changed)
OCL=18321
CL=18324