qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-22 06:04:39 -07:00
Code Releases Activity

delete unused file

Browse Source 
### 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
This commit is contained in:
Robert Griesemer 2009-09-25 15:43:43 -07:00
parent 908c8f909e
commit 0c18d1387d
1 changed files with 0 additions and 412 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

412
usr/gri/pretty/symboltable.go
View File

@ -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();
}