mirror of
https://github.com/golang/go
synced 2024-11-22 00:04:41 -07:00
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
This commit is contained in:
Robert Griesemer
parent
908c8f909e
commit
0c18d1387d
@ -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();
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user