delete unused file

### 3656
XXstart 3656
XXedit 3656 src/cmd/5g/ggen.c
XXedit 3656 src/pkg/runtime/arm/asm.s
XXedit 3656 test/arm-pass.txt
# submit 3656
hg ci -u 'Kai Backman <kaib@golang.org>' -d '1253922857 25200' -l - <<'HGEOF'
support for go and defer.

go/test: passes 64% (218/339)

R=rsc
APPROVED=rsc
DELTA=60  (39 added, 0 deleted, 21 changed)
OCL=35018
CL=35018

1 files changed, 0 insertions, 412 deletions

diff --git a/usr/gri/pretty/symboltable.go b/usr/gri/pretty/symboltable.go
deleted file mode 100644
index 3f707198a..000000000
--- a/usr/gri/pretty/symboltable.go
+++ /dev/null
@@ -1,412 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package SymbolTable
-
-import (
-	"container/vector";
-	"unicode";
-	"utf8";
-)
-
-
-// ----------------------------------------------------------------------------
-// Support
-
-func assert(pred bool) {
-	if !pred {
-		panic("assertion failed");
-	}
-}
-
-
-// ----------------------------------------------------------------------------
-// Objects
-
-// Object represents a language object, such as a constant, variable, type, etc.
-
-const /* kind */ (
-	BADOBJ = iota;  // error handling
-	NONE;  // kind unknown
-	CONST; TYPE; VAR; FIELD; FUNC; BUILTIN; PACKAGE; LABEL;
-	END;  // end of scope (import/export only)
-)
-
-
-func KindStr(kind int) string {
-	switch kind {
-	case BADOBJ: return "BADOBJ";
-	case NONE: return "NONE";
-	case CONST: return "CONST";
-	case TYPE: return "TYPE";
-	case VAR: return "VAR";
-	case FIELD: return "FIELD";
-	case FUNC: return "FUNC";
-	case BUILTIN: return "BUILTIN";
-	case PACKAGE: return "PACKAGE";
-	case LABEL: return "LABEL";
-	case END: return "END";
-	}
-	return "<unknown Object kind>";
-}
-
-
-type Object struct {
-	Id int;  // unique id
-
-	Pos int;  // source position (< 0 if unknown position)
-	Kind int;  // object kind
-	Ident string;
-	Typ *Type;  // nil for packages
-	Pnolev int;  // >= 0: package no., <= 0: function nesting level, 0: global level
-}
-
-
-func (obj *Object) IsExported() bool {
-	switch obj.Kind {
-	case NONE /* FUNC for now */, CONST, TYPE, VAR, FUNC:
-		ch, size := utf8.DecodeRuneInString(obj.Ident);
-		return unicode.IsUpper(ch);
-	}
-	return false;
-}
-
-
-func (obj* Object) String() string {
-	if obj != nil {
-		return
-			"Object(" +
-			KindStr(obj.Kind) + ", " +
-			obj.Ident +
-			")";
-	}
-	return "nil";
-}
-
-
-var Universe_void_typ *Type  // initialized by Universe to Universe.void_typ
-var objectId int;
-
-func NewObject(pos, kind int, ident string) *Object {
-	obj := new(Object);
-	obj.Id = objectId;
-	objectId++;
-
-	obj.Pos = pos;
-	obj.Kind = kind;
-	obj.Ident = ident;
-	obj.Typ = Universe_void_typ;  // TODO would it be better to use nil instead?
-	obj.Pnolev = 0;
-
-	return obj;
-}
-
-
-// ----------------------------------------------------------------------------
-// Scopes
-
-type Scope struct {
-	Parent *Scope;
-	entries map[string] *Object;
-}
-
-
-func NewScope(parent *Scope) *Scope {
-	scope := new(Scope);
-	scope.Parent = parent;
-	scope.entries = make(map[string] *Object, 8);
-	return scope;
-}
-
-
-func (scope *Scope) LookupLocal(ident string) *Object {
-	obj, found := scope.entries[ident];
-	if found {
-		return obj;
-	}
-	return nil;
-}
-
-
-func (scope *Scope) Lookup(ident string) *Object {
-	for scope != nil {
-		obj := scope.LookupLocal(ident);
-		if obj != nil {
-			return obj;
-		}
-		scope = scope.Parent;
-	}
-	return nil;
-}
-
-
-func (scope *Scope) add(obj *Object) {
-	scope.entries[obj.Ident] = obj;
-}
-
-
-func (scope *Scope) Insert(obj *Object) {
-	if scope.LookupLocal(obj.Ident) != nil {
-		panic("obj already inserted");
-	}
-	scope.add(obj);
-}
-
-
-func (scope *Scope) InsertImport(obj *Object) *Object {
-	 p := scope.LookupLocal(obj.Ident);
-	 if p == nil {
-		scope.add(obj);
-		p = obj;
-	 }
-	 return p;
-}
-
-
-func (scope *Scope) Print() {
-	print("scope {");
-	for key := range scope.entries {
-		print("\n  ", key);
-	}
-	print("\n}\n");
-}
-
-
-// ----------------------------------------------------------------------------
-// Types
-
-const /* form */ (
-	// internal types
-	// We should never see one of these.
-	UNDEF = iota;
-
-	// VOID types are used when we don't have a type. Never exported.
-	// (exported type forms must be > 0)
-	VOID;
-
-	// BADTYPE types are compatible with any type and don't cause further errors.
-	// They are introduced only as a result of an error in the source code. A
-	// correct program cannot have BAD types.
-	BADTYPE;
-
-	// FORWARD types are forward-declared (incomplete) types. They can only
-	// be used as element types of pointer types and must be resolved before
-	// their internals are accessible.
-	FORWARD;
-
-	// TUPLE types represent multi-valued result types of functions and
-	// methods.
-	TUPLE;
-
-	// The type of nil.
-	NIL;
-
-	// A type name
-	TYPENAME;
-
-	// basic types
-	BOOL; UINT; INT; FLOAT; STRING; INTEGER;
-
-	// composite types
-	ALIAS; ARRAY; STRUCT; INTERFACE; MAP; CHANNEL; FUNCTION; METHOD; POINTER;
-
-	// open-ended parameter type
-	ELLIPSIS
-)
-
-
-func FormStr(form int) string {
-	switch form {
-	case VOID: return "VOID";
-	case BADTYPE: return "BADTYPE";
-	case FORWARD: return "FORWARD";
-	case TUPLE: return "TUPLE";
-	case NIL: return "NIL";
-	case TYPENAME: return "TYPENAME";
-	case BOOL: return "BOOL";
-	case UINT: return "UINT";
-	case INT: return "INT";
-	case FLOAT: return "FLOAT";
-	case STRING: return "STRING";
-	case ALIAS: return "ALIAS";
-	case ARRAY: return "ARRAY";
-	case STRUCT: return "STRUCT";
-	case INTERFACE: return "INTERFACE";
-	case MAP: return "MAP";
-	case CHANNEL: return "CHANNEL";
-	case FUNCTION: return "FUNCTION";
-	case METHOD: return "METHOD";
-	case POINTER: return "POINTER";
-	case ELLIPSIS: return "ELLIPSIS";
-	}
-	return "<unknown Type form>";
-}
-
-
-const /* channel mode */ (
-	FULL = iota;
-	SEND;
-	RECV;
-)
-
-
-type Type struct {
-	Id int;  // unique id
-
-	Ref int;  // for exporting only: >= 0 means already exported
-	Form int;  // type form
-	Size int;  // size in bytes
-	Obj *Object;  // primary type object or nil
-	Scope *Scope;  // locals, fields & methods
-
-	// syntactic components
-	Pos int;  // source position (< 0 if unknown position)
-	Len int;  // array length
-	Mode int;  // channel mode
-	Key *Type;  // receiver type or map key
-	Elt *Type;  // type name type, array, map, channel or pointer element type, function result type
-	List *vector.Vector; End int;  // struct fields, interface methods, function parameters
-}
-
-
-var typeId int;
-
-func NewType(pos, form int) *Type {
-	typ := new(Type);
-	typ.Id = typeId;
-	typeId++;
-
-	typ.Ref = -1;  // not yet exported
-	typ.Pos = pos;
-	typ.Form = form;
-
-	return typ;
-}
-
-
-func (typ* Type) String() string {
-	if typ != nil {
-		return
-			"Type(" +
-			FormStr(typ.Form) +
-			")";
-	}
-	return "nil";
-}
-
-
-// ----------------------------------------------------------------------------
-// Universe scope
-
-var (
-	Universe *Scope;
-	PredeclaredTypes vector.Vector;
-
-	// internal types
-	Void_typ,
-	Bad_typ,
-	Nil_typ,
-
-	// basic types
-	Bool_typ,
-	Uint8_typ,
-	Uint16_typ,
-	Uint32_typ,
-	Uint64_typ,
-	Int8_typ,
-	Int16_typ,
-	Int32_typ,
-	Int64_typ,
-	Float32_typ,
-	Float64_typ,
-	Float80_typ,
-	String_typ,
-	Integer_typ,
-
-	// convenience types
-	Byte_typ,
-	Uint_typ,
-	Int_typ,
-	Float_typ,
-	Uintptr_typ *Type;
-
-	True_obj,
-	False_obj,
-	Iota_obj,
-	Nil_obj *Object;
-)
-
-
-func declObj(kind int, ident string, typ *Type) *Object {
-	obj := NewObject(-1 /* no source pos */, kind, ident);
-	obj.Typ = typ;
-	if kind == TYPE && typ.Obj == nil {
-		typ.Obj = obj;  // set primary type object
-	}
-	Universe.Insert(obj);
-	return obj
-}
-
-
-func declType(form int, ident string, size int) *Type {
-  typ := NewType(-1 /* no source pos */, form);
-  typ.Size = size;
-  return declObj(TYPE, ident, typ).Typ;
-}
-
-
-func register(typ *Type) *Type {
-	typ.Ref = PredeclaredTypes.Len();
-	PredeclaredTypes.Push(typ);
-	return typ;
-}
-
-
-func init() {
-	Universe = NewScope(nil);  // universe has no parent
-	PredeclaredTypes.Init(32);
-
-	// Interal types
-	Void_typ = NewType(-1 /* no source pos */, VOID);
-	Universe_void_typ = Void_typ;
-	Bad_typ = NewType(-1 /* no source pos */, BADTYPE);
-	Nil_typ = NewType(-1 /* no source pos */, NIL);
-
-	// Basic types
-	Bool_typ = register(declType(BOOL, "bool", 1));
-	Uint8_typ = register(declType(UINT, "uint8", 1));
-	Uint16_typ = register(declType(UINT, "uint16", 2));
-	Uint32_typ = register(declType(UINT, "uint32", 4));
-	Uint64_typ = register(declType(UINT, "uint64", 8));
-	Int8_typ = register(declType(INT, "int8", 1));
-	Int16_typ = register(declType(INT, "int16", 2));
-	Int32_typ = register(declType(INT, "int32", 4));
-	Int64_typ = register(declType(INT, "int64", 8));
-	Float32_typ = register(declType(FLOAT, "float32", 4));
-	Float64_typ = register(declType(FLOAT, "float64", 8));
-	Float80_typ = register(declType(FLOAT, "float80", 10));
-	String_typ = register(declType(STRING, "string", 8));
-	Integer_typ = register(declType(INTEGER, "integer", 8));
-
-	// All but 'byte' should be platform-dependent, eventually.
-	Byte_typ = register(declType(UINT, "byte", 1));
-	Uint_typ = register(declType(UINT, "uint", 4));
-	Int_typ = register(declType(INT, "int", 4));
-	Float_typ = register(declType(FLOAT, "float", 4));
-	Uintptr_typ = register(declType(UINT, "uintptr", 8));
-
-	// Predeclared constants
-	True_obj = declObj(CONST, "true", Bool_typ);
-	False_obj = declObj(CONST, "false", Bool_typ);
-	Iota_obj = declObj(CONST, "iota", Int_typ);
-	Nil_obj = declObj(CONST, "nil", Nil_typ);
-
-	// Builtin functions
-	declObj(BUILTIN, "len", Void_typ);
-	declObj(BUILTIN, "new", Void_typ);
-	declObj(BUILTIN, "panic", Void_typ);
-	declObj(BUILTIN, "print", Void_typ);
-
-	// scope.Print();
-}