export type Type interface {
Kind() int;
+ Name() string;
Size() uint64;
}
// -- Basic
type BasicType struct{
- name string;
kind int;
+ name string;
size uint64;
}
return t.typ
}
-func NewStubType(t Type) *StubType {
+func NewStubType(name string, t Type) *StubType {
s := new(StubType);
+ s.name = name;
s.typ = t;
return s;
}
-func NewNamedStubType(n string) *StubType {
- s := new(StubType);
- s.name = n;
- return s;
-}
-
// -- Pointer
export type PtrType interface {
}
type PtrTypeStruct struct {
- sub *StubType
+ name string;
+ sub *StubType;
}
func (t *PtrTypeStruct) Kind() int {
return PtrKind
}
+func (t *PtrTypeStruct) Name() string {
+ return t.name
+}
+
func (t *PtrTypeStruct) Size() uint64 {
return ptrsize
}
return t.sub.Get()
}
-func NewPtrTypeStruct(sub *StubType) *PtrTypeStruct {
+func NewPtrTypeStruct(name string, sub *StubType) *PtrTypeStruct {
t := new(PtrTypeStruct);
+ t.name = name;
t.sub = sub;
return t;
}
}
type ArrayTypeStruct struct {
+ name string;
elem *StubType;
open bool; // otherwise fixed size
len uint64;
return ArrayKind
}
+func (t *ArrayTypeStruct) Name() string {
+ return t.name
+}
+
func (t *ArrayTypeStruct) Size() uint64 {
if t.open {
return ptrsize // open arrays are pointers to structures
return t.elem.Get()
}
-func NewArrayTypeStruct(open bool, len uint64, elem *StubType) *ArrayTypeStruct {
+func NewArrayTypeStruct(name string, open bool, len uint64, elem *StubType) *ArrayTypeStruct {
t := new(ArrayTypeStruct);
+ t.name = name;
t.open = open;
t.len = len;
t.elem = elem;
}
type MapTypeStruct struct {
+ name string;
key *StubType;
elem *StubType;
}
return MapKind
}
+func (t *MapTypeStruct) Name() string {
+ return t.name
+}
+
func (t *MapTypeStruct) Size() uint64 {
panic("reflect.type: map.Size(): cannot happen");
return 0
return t.elem.Get()
}
-func NewMapTypeStruct(key, elem *StubType) *MapTypeStruct {
+func NewMapTypeStruct(name string, key, elem *StubType) *MapTypeStruct {
t := new(MapTypeStruct);
+ t.name = name;
t.key = key;
t.elem = elem;
return t;
)
type ChanTypeStruct struct {
+ name string;
elem *StubType;
dir int;
}
return ChanKind
}
+func (t *ChanTypeStruct) Name() string {
+ return t.name
+}
+
func (t *ChanTypeStruct) Size() uint64 {
panic("reflect.type: chan.Size(): cannot happen");
return 0
return t.elem.Get()
}
-func NewChanTypeStruct(dir int, elem *StubType) *ChanTypeStruct {
+func NewChanTypeStruct(name string, dir int, elem *StubType) *ChanTypeStruct {
t := new(ChanTypeStruct);
+ t.name = name;
t.dir = dir;
t.elem = elem;
return t;
}
type StructTypeStruct struct {
+ name string;
field *[]Field;
}
return StructKind
}
+func (t *StructTypeStruct) Name() string {
+ return t.name
+}
+
// TODO: not portable; depends on 6g
func (t *StructTypeStruct) Size() uint64 {
size := uint64(0);
return len(t.field)
}
-func NewStructTypeStruct(field *[]Field) *StructTypeStruct {
+func NewStructTypeStruct(name string, field *[]Field) *StructTypeStruct {
t := new(StructTypeStruct);
+ t.name = name;
t.field = field;
return t;
}
}
type InterfaceTypeStruct struct {
+ name string;
field *[]Field;
}
return len(t.field)
}
-func NewInterfaceTypeStruct(field *[]Field) *InterfaceTypeStruct {
+func NewInterfaceTypeStruct(name string, field *[]Field) *InterfaceTypeStruct {
t := new(InterfaceTypeStruct);
+ t.name = name;
t.field = field;
return t;
}
return InterfaceKind
}
+func (t *InterfaceTypeStruct) Name() string {
+ return t.name
+}
+
func (t *InterfaceTypeStruct) Size() uint64 {
return interfacesize
}
}
type FuncTypeStruct struct {
+ name string;
in *StructTypeStruct;
out *StructTypeStruct;
}
return FuncKind
}
+func (t *FuncTypeStruct) Name() string {
+ return t.name
+}
+
func (t *FuncTypeStruct) Size() uint64 {
panic("reflect.type: func.Size(): cannot happen");
return 0
return t.out
}
-func NewFuncTypeStruct(in, out *StructTypeStruct) *FuncTypeStruct {
+func NewFuncTypeStruct(name string, in, out *StructTypeStruct) *FuncTypeStruct {
t := new(FuncTypeStruct);
+ t.name = name;
t.in = in;
t.out = out;
return t;
types["string"] = &String;
// Basics get prebuilt stubs
- MissingStub = NewStubType(Missing);
+ MissingStub = NewStubType(MissingString, Missing);
basicstub[MissingString] = MissingStub;
- basicstub["int8"] = NewStubType(Int8);
- basicstub["int16"] = NewStubType(Int16);
- basicstub["int32"] = NewStubType(Int32);
- basicstub["int64"] = NewStubType(Int64);
- basicstub["uint8"] = NewStubType(Uint8);
- basicstub["uint16"] = NewStubType(Uint16);
- basicstub["uint32"] = NewStubType(Uint32);
- basicstub["uint64"] = NewStubType(Uint64);
- basicstub["float32"] = NewStubType(Float32);
- basicstub["float64"] = NewStubType(Float64);
- basicstub["float80"] = NewStubType(Float80);
- basicstub["string"] = NewStubType(String);
+ basicstub["int8"] = NewStubType("int8", Int8);
+ basicstub["int16"] = NewStubType("int16", Int16);
+ basicstub["int32"] = NewStubType("int32", Int32);
+ basicstub["int64"] = NewStubType("int64", Int64);
+ basicstub["uint8"] = NewStubType("uint8", Uint8);
+ basicstub["uint16"] = NewStubType("uint16", Uint16);
+ basicstub["uint32"] = NewStubType("uint32", Uint32);
+ basicstub["uint64"] = NewStubType("uint64", Uint64);
+ basicstub["float32"] = NewStubType("float32", Float32);
+ basicstub["float64"] = NewStubType("float64", Float64);
+ basicstub["float80"] = NewStubType("float80", Float80);
+ basicstub["string"] = NewStubType("string", String);
Unlock();
}
p.token = p.str[start : p.index];
}
-func (p *Parser) Type() *StubType
+func (p *Parser) Type(name string) *StubType
-func (p *Parser) Array() *StubType {
+func (p *Parser) Array(name string) *StubType {
size := uint64(0);
open := true;
if p.token != "]" {
return MissingStub
}
p.Next();
- elemtype := p.Type();
- return NewStubType(NewArrayTypeStruct(open, size, elemtype));
+ elemtype := p.Type("");
+ return NewStubType(name, NewArrayTypeStruct(name, open, size, elemtype));
}
-func (p *Parser) Map() *StubType {
+func (p *Parser) Map(name string) *StubType {
if p.token != "[" {
return MissingStub
}
p.Next();
- keytype := p.Type();
+ keytype := p.Type("");
if p.token != "]" {
return MissingStub
}
p.Next();
- elemtype := p.Type();
- return NewStubType(NewMapTypeStruct(keytype, elemtype));
+ elemtype := p.Type("");
+ return NewStubType(name, NewMapTypeStruct(name, keytype, elemtype));
}
-func (p *Parser) Chan(dir int) *StubType {
+func (p *Parser) Chan(name string, dir int) *StubType {
if p.token == "<-" {
if dir != BothDir {
return MissingStub
p.Next();
dir = SendDir;
}
- elemtype := p.Type();
- return NewStubType(NewChanTypeStruct(dir, elemtype));
+ elemtype := p.Type("");
+ return NewStubType(name, NewChanTypeStruct(name, dir, elemtype));
}
// Parse array of fields for struct, interface, and func arguments
}
a[nf].name = p.token;
p.Next();
- a[nf].typ = p.Type();
+ a[nf].typ = p.Type("");
nf++;
if p.token != sep {
break;
return a[0:nf];
}
-func (p *Parser) Struct() *StubType {
+func (p *Parser) Struct(name string) *StubType {
f := p.Fields(";");
if p.token != "}" {
return MissingStub;
}
p.Next();
- return NewStubType(NewStructTypeStruct(f));
+ return NewStubType(name, NewStructTypeStruct(name, f));
}
-func (p *Parser) Interface() *StubType {
+func (p *Parser) Interface(name string) *StubType {
f := p.Fields(";");
if p.token != "}" {
return MissingStub;
}
p.Next();
- return NewStubType(NewInterfaceTypeStruct(f));
+ return NewStubType(name, NewInterfaceTypeStruct(name, f));
}
-func (p *Parser) Func() *StubType {
+func (p *Parser) Func(name string) *StubType {
// may be 1 or 2 parenthesized lists
- f1 := NewStructTypeStruct(p.Fields(","));
+ f1 := NewStructTypeStruct("", p.Fields(","));
if p.token != ")" {
return MissingStub;
}
p.Next();
if p.token != "(" {
// 1 list: the in parameters only
- return NewStubType(NewFuncTypeStruct(f1, nil));
+ return NewStubType(name, NewFuncTypeStruct(name, f1, nil));
}
p.Next();
- f2 := NewStructTypeStruct(p.Fields(","));
+ f2 := NewStructTypeStruct("", p.Fields(","));
if p.token != ")" {
return MissingStub;
}
p.Next();
// 2 lists: the in and out parameters are present
- return NewStubType(NewFuncTypeStruct(f1, f2));
+ return NewStubType(name, NewFuncTypeStruct(name, f1, f2));
}
-func (p *Parser) Type() *StubType {
+func (p *Parser) Type(name string) *StubType {
dir := BothDir;
switch {
case p.token == "":
return nil;
case p.token == "*":
p.Next();
- return NewStubType(NewPtrTypeStruct(p.Type()));
+ return NewStubType(name, NewPtrTypeStruct(name, p.Type("")));
case p.token == "[":
p.Next();
- return p.Array();
+ return p.Array(name);
case p.token == "map":
p.Next();
- return p.Map();
+ return p.Map(name);
case p.token == "<-":
p.Next();
dir = RecvDir;
fallthrough;
case p.token == "chan":
p.Next();
- return p.Chan(dir);
+ return p.Chan(name, dir);
case p.token == "struct":
p.Next();
if p.token != "{" {
return MissingStub
}
p.Next();
- return p.Struct();
+ return p.Struct(name);
case p.token == "interface":
p.Next();
if p.token != "{" {
return MissingStub
}
p.Next();
- return p.Interface();
+ return p.Interface(name);
case p.token == "(":
p.Next();
- return p.Func();
+ return p.Func(name);
case isdigit(p.token[0]):
p.Next();
return MissingStub;
// must be an identifier. is it basic? if so, we have a stub
if s, ok := basicstub[p.token]; ok {
p.Next();
+ if name != "" {
+ // Need to make a copy because we are renaming a basic type
+ b := s.Get();
+ s = NewStubType(name, NewBasicType(name, b.Kind(), b.Size()));
+ }
return s
}
// not a basic - must be of the form "P.T"
p.Next();
return MissingStub;
}
- s := new(StubType);
- s.name = p.token;
+ s := NewStubType(p.token, nil);
p.Next();
return s;
}
-export func ParseTypeString(str string) Type {
+export func ParseTypeString(name, typestring string) Type {
p := new(Parser);
- p.str = str;
+ p.str = typestring;
p.Next();
- return p.Type().Get();
+ return p.Type(name).Get();
}
// Create typestring map from reflect.typestrings() data. Lock is held.
return *t
}
types[name] = &Missing; // prevent recursion; will overwrite
- t1 := ParseTypeString(TypeNameToTypeString(name));
+ t1 := ParseTypeString(name, TypeNameToTypeString(name));
p := new(Type);
*p = t1;
types[name] = p;