assert(reflect.ValueToString(v), t);
}
-export type empty interface {}
-
export type T struct { a int; b float64; c string; d *int }
export func TestAll(tt *testing.T) { // TODO(r): wrap up better
}
}
-type Big struct {
+type big struct {
a, b, c, d, e int64
}
export func TestBigStruct(t *testing.T) {
- b := Big{1, 2, 3, 4, 5};
+ b := big{1, 2, 3, 4, 5};
v := NewValue(b);
- b1 := v.Interface().(Big);
+ b1 := v.Interface().(big);
if b1.a != b.a || b1.b != b.b || b1.c != b.c || b1.d != b.d || b1.e != b.e {
- t.Errorf("NewValue(%v).Interface().(Big) = %v", b, b1);
+ t.Errorf("NewValue(%v).Interface().(big) = %v", b, b1);
}
}
export func TypeToString(typ Type, expand bool) string
export func ValueToString(val Value) string
-func DoubleQuote(s string) string {
+func doubleQuote(s string) string {
out := "\"";
for i := 0; i < len(s); i++ {
c := s[i];
return out;
}
-type HasFields interface {
+type hasFields interface {
Field(i int) (name string, typ Type, tag string, offset int);
Len() int;
}
-func TypeFieldsToString(t HasFields, sep string) string {
+func typeFieldsToString(t hasFields, sep string) string {
var str string;
for i := 0; i < t.Len(); i++ {
str1, typ, tag, offset := t.Field(i);
}
str1 += TypeToString(typ, false);
if tag != "" {
- str1 += " " + DoubleQuote(tag);
+ str1 += " " + doubleQuote(tag);
}
if i < t.Len() - 1 {
str1 += sep + " ";
return str;
}
-func TypeToString(typ Type, expand bool) string {
+export func TypeToString(typ Type, expand bool) string {
var str string;
if name := typ.Name(); !expand && name != "" {
return name
}
return str + TypeToString(c.Elem(), false);
case StructKind:
- return "struct{" + TypeFieldsToString(typ, ";") + "}";
+ return "struct{" + typeFieldsToString(typ, ";") + "}";
case InterfaceKind:
- return "interface{" + TypeFieldsToString(typ, ";") + "}";
+ return "interface{" + typeFieldsToString(typ, ";") + "}";
case FuncKind:
f := typ.(FuncType);
- str = "(" + TypeFieldsToString(f.In(), ",") + ")";
+ str = "(" + typeFieldsToString(f.In(), ",") + ")";
if f.Out() != nil {
- str += "(" + TypeFieldsToString(f.Out(), ",") + ")";
+ str += "(" + typeFieldsToString(f.Out(), ",") + ")";
}
return str;
default:
return strconv.Itoa64(v);
}
-func ValueToString(val Value) string {
+export func ValueToString(val Value) string {
var str string;
typ := val.Type();
switch(val.Kind()) {
var ptrsize int
var interfacesize int
-var MissingString = "$missing$" // syntactic name for undefined type names
-var DotDotDotString = "..."
+var missingString = "$missing$" // syntactic name for undefined type names
+var dotDotDotString = "..."
export type Type interface {
Kind() int;
// -- Basic
-type BasicType struct {
+type basicType struct {
commonType
}
-func NewBasicType(name string, kind int, size int) Type {
- return &BasicType{ commonType{kind, name, name, size} }
+func newBasicType(name string, kind int, size int) Type {
+ return &basicType{ commonType{kind, name, name, size} }
}
// Prebuilt basic types
export var (
- Missing = NewBasicType(MissingString, MissingKind, 1);
- DotDotDot = NewBasicType(DotDotDotString, DotDotDotKind, 16); // TODO(r): size of interface?
- Bool = NewBasicType("bool", BoolKind, 1); // TODO: need to know how big a bool is
- Int = NewBasicType("int", IntKind, 4); // TODO: need to know how big an int is
- Int8 = NewBasicType("int8", Int8Kind, 1);
- Int16 = NewBasicType("int16", Int16Kind, 2);
- Int32 = NewBasicType("int32", Int32Kind, 4);
- Int64 = NewBasicType("int64", Int64Kind, 8);
- Uint = NewBasicType("uint", UintKind, 4); // TODO: need to know how big a uint is
- Uint8 = NewBasicType("uint8", Uint8Kind, 1);
- Uint16 = NewBasicType("uint16", Uint16Kind, 2);
- Uint32 = NewBasicType("uint32", Uint32Kind, 4);
- Uint64 = NewBasicType("uint64", Uint64Kind, 8);
- Uintptr = NewBasicType("uintptr", UintptrKind, 8); // TODO: need to know how big a uintptr is
- Float = NewBasicType("float", FloatKind, 4); // TODO: need to know how big a float is
- Float32 = NewBasicType("float32", Float32Kind, 4);
- Float64 = NewBasicType("float64", Float64Kind, 8);
- Float80 = NewBasicType("float80", Float80Kind, 10); // TODO: strange size?
- String = NewBasicType("string", StringKind, 8); // implemented as a pointer
+ Missing = newBasicType(missingString, MissingKind, 1);
+ DotDotDot = newBasicType(dotDotDotString, DotDotDotKind, 16); // TODO(r): size of interface?
+ Bool = newBasicType("bool", BoolKind, 1); // TODO: need to know how big a bool is
+ Int = newBasicType("int", IntKind, 4); // TODO: need to know how big an int is
+ Int8 = newBasicType("int8", Int8Kind, 1);
+ Int16 = newBasicType("int16", Int16Kind, 2);
+ Int32 = newBasicType("int32", Int32Kind, 4);
+ Int64 = newBasicType("int64", Int64Kind, 8);
+ Uint = newBasicType("uint", UintKind, 4); // TODO: need to know how big a uint is
+ Uint8 = newBasicType("uint8", Uint8Kind, 1);
+ Uint16 = newBasicType("uint16", Uint16Kind, 2);
+ Uint32 = newBasicType("uint32", Uint32Kind, 4);
+ Uint64 = newBasicType("uint64", Uint64Kind, 8);
+ Uintptr = newBasicType("uintptr", UintptrKind, 8); // TODO: need to know how big a uintptr is
+ Float = newBasicType("float", FloatKind, 4); // TODO: need to know how big a float is
+ Float32 = newBasicType("float32", Float32Kind, 4);
+ Float64 = newBasicType("float64", Float64Kind, 8);
+ Float80 = newBasicType("float80", Float80Kind, 10); // TODO: strange size?
+ String = newBasicType("string", StringKind, 8); // implemented as a pointer
)
// Stub types allow us to defer evaluating type names until needed.
// If the name is empty, the type must be non-nil.
-type StubType struct {
+type stubType struct {
name string;
typ Type;
}
-func NewStubType(name string, typ Type) *StubType {
- return &StubType{name, typ}
+func newStubType(name string, typ Type) *stubType {
+ return &stubType{name, typ}
}
-func (t *StubType) Get() Type {
+func (t *stubType) Get() Type {
if t.typ == nil {
t.typ = ExpandType(t.name)
}
Sub() Type
}
-type PtrTypeStruct struct {
+type ptrTypeStruct struct {
commonType;
- sub *StubType;
+ sub *stubType;
}
-func NewPtrTypeStruct(name, typestring string, sub *StubType) *PtrTypeStruct {
- return &PtrTypeStruct{ commonType{PtrKind, typestring, name, ptrsize}, sub}
+func newPtrTypeStruct(name, typestring string, sub *stubType) *ptrTypeStruct {
+ return &ptrTypeStruct{ commonType{PtrKind, typestring, name, ptrsize}, sub}
}
-func (t *PtrTypeStruct) Sub() Type {
+func (t *ptrTypeStruct) Sub() Type {
return t.sub.Get()
}
Elem() Type;
}
-type ArrayTypeStruct struct {
+type arrayTypeStruct struct {
commonType;
- elem *StubType;
+ elem *stubType;
open bool; // otherwise fixed size
len int;
}
-func NewArrayTypeStruct(name, typestring string, open bool, len int, elem *StubType) *ArrayTypeStruct {
- return &ArrayTypeStruct{ commonType{ArrayKind, typestring, name, 0}, elem, open, len}
+func newArrayTypeStruct(name, typestring string, open bool, len int, elem *stubType) *arrayTypeStruct {
+ return &arrayTypeStruct{ commonType{ArrayKind, typestring, name, 0}, elem, open, len}
}
-func (t *ArrayTypeStruct) Size() int {
+func (t *arrayTypeStruct) Size() int {
if t.open {
return ptrsize*2 // open arrays are 2-word headers
}
return t.len * t.elem.Get().Size();
}
-func (t *ArrayTypeStruct) Open() bool {
+func (t *arrayTypeStruct) Open() bool {
return t.open
}
-func (t *ArrayTypeStruct) Len() int {
+func (t *arrayTypeStruct) Len() int {
// what about open array? TODO
return t.len
}
-func (t *ArrayTypeStruct) Elem() Type {
+func (t *arrayTypeStruct) Elem() Type {
return t.elem.Get()
}
Elem() Type;
}
-type MapTypeStruct struct {
+type mapTypeStruct struct {
commonType;
- key *StubType;
- elem *StubType;
+ key *stubType;
+ elem *stubType;
}
-func NewMapTypeStruct(name, typestring string, key, elem *StubType) *MapTypeStruct {
- return &MapTypeStruct{ commonType{MapKind, typestring, name, ptrsize}, key, elem}
+func newMapTypeStruct(name, typestring string, key, elem *stubType) *mapTypeStruct {
+ return &mapTypeStruct{ commonType{MapKind, typestring, name, ptrsize}, key, elem}
}
-func (t *MapTypeStruct) Key() Type {
+func (t *mapTypeStruct) Key() Type {
return t.key.Get()
}
-func (t *MapTypeStruct) Elem() Type {
+func (t *mapTypeStruct) Elem() Type {
return t.elem.Get()
}
BothDir = SendDir | RecvDir;
)
-type ChanTypeStruct struct {
+type chanTypeStruct struct {
commonType;
- elem *StubType;
+ elem *stubType;
dir int;
}
-func NewChanTypeStruct(name, typestring string, dir int, elem *StubType) *ChanTypeStruct {
- return &ChanTypeStruct{ commonType{ChanKind, typestring, name, ptrsize}, elem, dir}
+func newChanTypeStruct(name, typestring string, dir int, elem *stubType) *chanTypeStruct {
+ return &chanTypeStruct{ commonType{ChanKind, typestring, name, ptrsize}, elem, dir}
}
-func (t *ChanTypeStruct) Dir() int {
+func (t *chanTypeStruct) Dir() int {
return t.dir
}
-func (t *ChanTypeStruct) Elem() Type {
+func (t *chanTypeStruct) Elem() Type {
return t.elem.Get()
}
Len() int;
}
-type Field struct {
+type structField struct {
name string;
- typ *StubType;
+ typ *stubType;
tag string;
size int;
offset int;
}
-type StructTypeStruct struct {
+type structTypeStruct struct {
commonType;
- field []Field;
+ field []structField;
}
-func NewStructTypeStruct(name, typestring string, field []Field) *StructTypeStruct {
- return &StructTypeStruct{ commonType{StructKind, typestring, name, 0}, field}
+func newStructTypeStruct(name, typestring string, field []structField) *structTypeStruct {
+ return &structTypeStruct{ commonType{StructKind, typestring, name, 0}, field}
}
// TODO: not portable; depends on 6g
-func (t *StructTypeStruct) Size() int {
+func (t *structTypeStruct) Size() int {
if t.size > 0 {
return t.size
}
return size;
}
-func (t *StructTypeStruct) Field(i int) (name string, typ Type, tag string, offset int) {
+func (t *structTypeStruct) Field(i int) (name string, typ Type, tag string, offset int) {
if t.field[i].offset == 0 {
t.Size(); // will compute offsets
}
return t.field[i].name, t.field[i].typ.Get(), t.field[i].tag, t.field[i].offset
}
-func (t *StructTypeStruct) Len() int {
+func (t *structTypeStruct) Len() int {
return len(t.field)
}
Len() int;
}
-type InterfaceTypeStruct struct {
+type interfaceTypeStruct struct {
commonType;
- field []Field;
+ field []structField;
}
-func NewInterfaceTypeStruct(name, typestring string, field []Field) *InterfaceTypeStruct {
- return &InterfaceTypeStruct{ commonType{InterfaceKind, typestring, name, interfacesize}, field }
+func newInterfaceTypeStruct(name, typestring string, field []structField) *interfaceTypeStruct {
+ return &interfaceTypeStruct{ commonType{InterfaceKind, typestring, name, interfacesize}, field }
}
-func (t *InterfaceTypeStruct) Field(i int) (name string, typ Type, tag string, offset int) {
+func (t *interfaceTypeStruct) Field(i int) (name string, typ Type, tag string, offset int) {
return t.field[i].name, t.field[i].typ.Get(), "", 0
}
-func (t *InterfaceTypeStruct) Len() int {
+func (t *interfaceTypeStruct) Len() int {
return len(t.field)
}
-var NilInterface = NewInterfaceTypeStruct("nil", "", make([]Field, 0));
+var nilInterface = newInterfaceTypeStruct("nil", "", make([]structField, 0));
// -- Func
Out() StructType;
}
-type FuncTypeStruct struct {
+type funcTypeStruct struct {
commonType;
- in *StructTypeStruct;
- out *StructTypeStruct;
+ in *structTypeStruct;
+ out *structTypeStruct;
}
-func NewFuncTypeStruct(name, typestring string, in, out *StructTypeStruct) *FuncTypeStruct {
- return &FuncTypeStruct{ commonType{FuncKind, typestring, name, 0}, in, out }
+func newFuncTypeStruct(name, typestring string, in, out *structTypeStruct) *funcTypeStruct {
+ return &funcTypeStruct{ commonType{FuncKind, typestring, name, 0}, in, out }
}
-func (t *FuncTypeStruct) Size() int {
+func (t *funcTypeStruct) Size() int {
panic("reflect.type: func.Size(): cannot happen");
return 0
}
-func (t *FuncTypeStruct) In() StructType {
+func (t *funcTypeStruct) In() StructType {
return t.in
}
-func (t *FuncTypeStruct) Out() StructType {
+func (t *funcTypeStruct) Out() StructType {
if t.out == nil { // nil.(StructType) != nil so make sure caller sees real nil
return nil
}
var typestring map[string] string
var initialized bool = false
-// Map of basic types to prebuilt StubTypes
-var basicstub map[string] *StubType
+// Map of basic types to prebuilt stubTypes
+var basicstub map[string] *stubType
-var MissingStub *StubType;
-var DotDotDotStub *StubType;
+var missingStub *stubType;
+var dotDotDotStub *stubType;
// The database stored in the maps is global; use locking to guarantee safety.
var typestringlock sync.Mutex
-func Lock() {
+func lock() {
typestringlock.Lock()
}
-func Unlock() {
+func unlock() {
typestringlock.Unlock()
}
ptrsize = 8; // TODO: compute this
interfacesize = 2*ptrsize; // TODO: compute this
- Lock(); // not necessary because of init ordering but be safe.
+ lock(); // not necessary because of init ordering but be safe.
types = make(map[string] Type);
typestring = make(map[string] string);
- basicstub = make(map[string] *StubType);
+ basicstub = make(map[string] *stubType);
// Basics go into types table
- types[MissingString] = Missing;
- types[DotDotDotString] = DotDotDot;
+ types[missingString] = Missing;
+ types[dotDotDotString] = DotDotDot;
types["int"] = Int;
types["int8"] = Int8;
types["int16"] = Int16;
types["bool"] = Bool;
// Basics get prebuilt stubs
- MissingStub = NewStubType(MissingString, Missing);
- DotDotDotStub = NewStubType(DotDotDotString, DotDotDot);
- basicstub[MissingString] = MissingStub;
- basicstub[DotDotDotString] = DotDotDotStub;
- basicstub["int"] = NewStubType("int", Int);
- basicstub["int8"] = NewStubType("int8", Int8);
- basicstub["int16"] = NewStubType("int16", Int16);
- basicstub["int32"] = NewStubType("int32", Int32);
- basicstub["int64"] = NewStubType("int64", Int64);
- basicstub["uint"] = NewStubType("uint", Uint);
- basicstub["uint8"] = NewStubType("uint8", Uint8);
- basicstub["uint16"] = NewStubType("uint16", Uint16);
- basicstub["uint32"] = NewStubType("uint32", Uint32);
- basicstub["uint64"] = NewStubType("uint64", Uint64);
- basicstub["uintptr"] = NewStubType("uintptr", Uintptr);
- basicstub["float"] = NewStubType("float", Float);
- basicstub["float32"] = NewStubType("float32", Float32);
- basicstub["float64"] = NewStubType("float64", Float64);
- basicstub["float80"] = NewStubType("float80", Float80);
- basicstub["string"] = NewStubType("string", String);
- basicstub["bool"] = NewStubType("bool", Bool);
-
- Unlock();
+ missingStub = newStubType(missingString, Missing);
+ dotDotDotStub = newStubType(dotDotDotString, DotDotDot);
+ basicstub[missingString] = missingStub;
+ basicstub[dotDotDotString] = dotDotDotStub;
+ basicstub["int"] = newStubType("int", Int);
+ basicstub["int8"] = newStubType("int8", Int8);
+ basicstub["int16"] = newStubType("int16", Int16);
+ basicstub["int32"] = newStubType("int32", Int32);
+ basicstub["int64"] = newStubType("int64", Int64);
+ basicstub["uint"] = newStubType("uint", Uint);
+ basicstub["uint8"] = newStubType("uint8", Uint8);
+ basicstub["uint16"] = newStubType("uint16", Uint16);
+ basicstub["uint32"] = newStubType("uint32", Uint32);
+ basicstub["uint64"] = newStubType("uint64", Uint64);
+ basicstub["uintptr"] = newStubType("uintptr", Uintptr);
+ basicstub["float"] = newStubType("float", Float);
+ basicstub["float32"] = newStubType("float32", Float32);
+ basicstub["float64"] = newStubType("float64", Float64);
+ basicstub["float80"] = newStubType("float80", Float80);
+ basicstub["string"] = newStubType("string", String);
+ basicstub["bool"] = newStubType("bool", Bool);
+
+ unlock();
}
/*
}
// Simple parser for type strings
-type Parser struct {
+type typeParser struct {
str string; // string being parsed
token string; // the token being parsed now
tokstart int; // starting position of token
// Return typestring starting at position i. It will finish at the
// end of the previous token (before trailing white space).
-func (p *Parser) TypeString(i int) string {
+func (p *typeParser) TypeString(i int) string {
return p.str[i:p.prevend];
}
// Load next token into p.token
-func (p *Parser) Next() {
+func (p *typeParser) Next() {
p.prevend = p.index;
token := "";
for ; p.index < len(p.str) && p.str[p.index] == ' '; p.index++ {
}
fallthrough; // shouldn't happen but let the parser figure it out
case c == '.':
- if p.index < len(p.str)+2 && p.str[p.index-1:p.index+2] == DotDotDotString {
+ if p.index < len(p.str)+2 && p.str[p.index-1:p.index+2] == dotDotDotString {
p.index += 2;
- p.token = DotDotDotString;
+ p.token = dotDotDotString;
return;
}
fallthrough; // shouldn't happen but let the parser figure it out
p.token = p.str[start : p.index];
}
-func (p *Parser) Type(name string) *StubType
+func (p *typeParser) Type(name string) *stubType
-func (p *Parser) Array(name string, tokstart int) *StubType {
+func (p *typeParser) Array(name string, tokstart int) *stubType {
size := 0;
open := true;
if p.token != "]" {
if len(p.token) == 0 || !isdigit(p.token[0]) {
- return MissingStub
+ return missingStub
}
// write our own (trivial and simpleminded) atoi to avoid dependency
size = 0;
open = false;
}
if p.token != "]" {
- return MissingStub
+ return missingStub
}
p.Next();
elemtype := p.Type("");
- return NewStubType(name, NewArrayTypeStruct(name, p.TypeString(tokstart), open, size, elemtype));
+ return newStubType(name, newArrayTypeStruct(name, p.TypeString(tokstart), open, size, elemtype));
}
-func (p *Parser) Map(name string, tokstart int) *StubType {
+func (p *typeParser) Map(name string, tokstart int) *stubType {
if p.token != "[" {
- return MissingStub
+ return missingStub
}
p.Next();
keytype := p.Type("");
if p.token != "]" {
- return MissingStub
+ return missingStub
}
p.Next();
elemtype := p.Type("");
- return NewStubType(name, NewMapTypeStruct(name, p.TypeString(tokstart), keytype, elemtype));
+ return newStubType(name, newMapTypeStruct(name, p.TypeString(tokstart), keytype, elemtype));
}
-func (p *Parser) Chan(name string, tokstart, dir int) *StubType {
+func (p *typeParser) Chan(name string, tokstart, dir int) *stubType {
if p.token == "<-" {
if dir != BothDir {
- return MissingStub
+ return missingStub
}
p.Next();
dir = SendDir;
}
elemtype := p.Type("");
- return NewStubType(name, NewChanTypeStruct(name, p.TypeString(tokstart), dir, elemtype));
+ return newStubType(name, newChanTypeStruct(name, p.TypeString(tokstart), dir, elemtype));
}
// Parse array of fields for struct, interface, and func arguments
-func (p *Parser) Fields(sep, term string) []Field {
- a := make([]Field, 10);
+func (p *typeParser) Fields(sep, term string) []structField {
+ a := make([]structField, 10);
nf := 0;
for p.token != "" && p.token != term {
if nf == len(a) {
- a1 := make([]Field, 2*nf);
+ a1 := make([]structField, 2*nf);
for i := 0; i < nf; i++ {
a1[i] = a[i];
}
}
// A single type packaged as a field for a function return
-func (p *Parser) OneField() []Field {
- a := make([]Field, 1);
+func (p *typeParser) OneField() []structField {
+ a := make([]structField, 1);
a[0].name = "";
a[0].typ = p.Type("");
return a;
}
-func (p *Parser) Struct(name string, tokstart int) *StubType {
+func (p *typeParser) Struct(name string, tokstart int) *stubType {
f := p.Fields(";", "}");
if p.token != "}" {
- return MissingStub;
+ return missingStub;
}
p.Next();
- return NewStubType(name, NewStructTypeStruct(name, p.TypeString(tokstart), f));
+ return newStubType(name, newStructTypeStruct(name, p.TypeString(tokstart), f));
}
-func (p *Parser) Interface(name string, tokstart int) *StubType {
+func (p *typeParser) Interface(name string, tokstart int) *stubType {
f := p.Fields(";", "}");
if p.token != "}" {
- return MissingStub;
+ return missingStub;
}
p.Next();
- return NewStubType(name, NewInterfaceTypeStruct(name, p.TypeString(tokstart), f));
+ return newStubType(name, newInterfaceTypeStruct(name, p.TypeString(tokstart), f));
}
-func (p *Parser) Func(name string, tokstart int) *StubType {
+func (p *typeParser) Func(name string, tokstart int) *stubType {
// may be 1 or 2 parenthesized lists
- f1 := NewStructTypeStruct("", "", p.Fields(",", ")"));
+ f1 := newStructTypeStruct("", "", p.Fields(",", ")"));
if p.token != ")" {
- return MissingStub;
+ return missingStub;
}
p.Next();
if p.token != "(" {
// 1 list: the in parameters are a list. Is there a single out parameter?
if p.token == "" || p.token == "}" || p.token == "," || p.token == ";" {
- return NewStubType(name, NewFuncTypeStruct(name, p.TypeString(tokstart), f1, nil));
+ return newStubType(name, newFuncTypeStruct(name, p.TypeString(tokstart), f1, nil));
}
// A single out parameter.
- f2 := NewStructTypeStruct("", "", p.OneField());
- return NewStubType(name, NewFuncTypeStruct(name, p.TypeString(tokstart), f1, f2));
+ f2 := newStructTypeStruct("", "", p.OneField());
+ return newStubType(name, newFuncTypeStruct(name, p.TypeString(tokstart), f1, f2));
} else {
p.Next();
}
- f2 := NewStructTypeStruct("", "", p.Fields(",", ")"));
+ f2 := newStructTypeStruct("", "", p.Fields(",", ")"));
if p.token != ")" {
- return MissingStub;
+ return missingStub;
}
p.Next();
// 2 lists: the in and out parameters are present
- return NewStubType(name, NewFuncTypeStruct(name, p.TypeString(tokstart), f1, f2));
+ return newStubType(name, newFuncTypeStruct(name, p.TypeString(tokstart), f1, f2));
}
-func (p *Parser) Type(name string) *StubType {
+func (p *typeParser) Type(name string) *stubType {
dir := BothDir;
tokstart := p.tokstart;
switch {
case p.token == "*":
p.Next();
sub := p.Type("");
- return NewStubType(name, NewPtrTypeStruct(name, p.TypeString(tokstart), sub));
+ return newStubType(name, newPtrTypeStruct(name, p.TypeString(tokstart), sub));
case p.token == "[":
p.Next();
return p.Array(name, tokstart);
p.Next();
dir = RecvDir;
if p.token != "chan" {
- return MissingStub;
+ return missingStub;
}
fallthrough;
case p.token == "chan":
case p.token == "struct":
p.Next();
if p.token != "{" {
- return MissingStub
+ return missingStub
}
p.Next();
return p.Struct(name, tokstart);
case p.token == "interface":
p.Next();
if p.token != "{" {
- return MissingStub
+ return missingStub
}
p.Next();
return p.Interface(name, tokstart);
return p.Func(name, tokstart);
case isdigit(p.token[0]):
p.Next();
- return MissingStub;
+ return missingStub;
case special(p.token[0]):
p.Next();
- return MissingStub;
+ return missingStub;
}
// must be an identifier. is it basic? if so, we have a stub
if s, ok := basicstub[p.token]; ok {
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()));
+ s = newStubType(name, newBasicType(name, b.Kind(), b.Size()));
}
return s
}
}
if ndot != 1 {
p.Next();
- return MissingStub;
+ return missingStub;
}
- s := NewStubType(p.token, nil);
+ s := newStubType(p.token, nil);
p.Next();
return s;
}
export func ParseTypeString(name, typestring string) Type {
if typestring == "" {
// If the typestring is empty, it represents (the type of) a nil interface value
- return NilInterface
+ return nilInterface
}
- p := new(Parser);
+ p := new(typeParser);
p.str = typestring;
p.Next();
return p.Type(name).Get();
}
// Create typestring map from reflect.typestrings() data. Lock is held.
-func InitializeTypeStrings() {
+func initializeTypeStrings() {
if initialized {
return
}
}
// Look up type string associated with name. Lock is held.
-func TypeNameToTypeString(name string) string {
+func typeNameToTypeString(name string) string {
s, ok := typestring[name];
if !ok {
- InitializeTypeStrings();
+ initializeTypeStrings();
s, ok = typestring[name];
if !ok {
- s = MissingString;
+ s = missingString;
typestring[name] = s;
}
}
}
// Type is known by name. Find (and create if necessary) its real type.
-func ExpandType(name string) Type {
- Lock();
+export func ExpandType(name string) Type {
+ lock();
t, ok := types[name];
if ok {
- Unlock();
+ unlock();
return t
}
types[name] = Missing; // prevent recursion; will overwrite
- t1 := ParseTypeString(name, TypeNameToTypeString(name));
+ t1 := ParseTypeString(name, typeNameToTypeString(name));
types[name] = t1;
- Unlock();
+ unlock();
return t1;
}
"unsafe";
)
-type Addr unsafe.pointer
+export type Addr unsafe.pointer
-func EqualType(a, b Type) bool {
+func equalType(a, b Type) bool {
return a.String() == b.String()
}
return i;
}
-func NewValueAddr(typ Type, addr Addr) Value
+func newValueAddr(typ Type, addr Addr) Value
-type Creator *(typ Type, addr Addr) Value
+type creatorFn *(typ Type, addr Addr) Value
// -- Missing
Addr() Addr;
}
-type MissingValueStruct struct {
+type missingValueStruct struct {
commonValue
}
-func MissingCreator(typ Type, addr Addr) Value {
- return &MissingValueStruct{ commonValue{MissingKind, typ, addr} }
+func missingCreator(typ Type, addr Addr) Value {
+ return &missingValueStruct{ commonValue{MissingKind, typ, addr} }
}
// -- Int
Type() Type;
}
-type IntValueStruct struct {
+type intValueStruct struct {
commonValue
}
-func IntCreator(typ Type, addr Addr) Value {
- return &IntValueStruct{ commonValue{IntKind, typ, addr} }
+func intCreator(typ Type, addr Addr) Value {
+ return &intValueStruct{ commonValue{IntKind, typ, addr} }
}
-func (v *IntValueStruct) Get() int {
+func (v *intValueStruct) Get() int {
return *v.addr.(*int)
}
-func (v *IntValueStruct) Set(i int) {
+func (v *intValueStruct) Set(i int) {
*v.addr.(*int) = i
}
Type() Type;
}
-type Int8ValueStruct struct {
+type int8ValueStruct struct {
commonValue
}
-func Int8Creator(typ Type, addr Addr) Value {
- return &Int8ValueStruct{ commonValue{Int8Kind, typ, addr} }
+func int8Creator(typ Type, addr Addr) Value {
+ return &int8ValueStruct{ commonValue{Int8Kind, typ, addr} }
}
-func (v *Int8ValueStruct) Get() int8 {
+func (v *int8ValueStruct) Get() int8 {
return *v.addr.(*int8)
}
-func (v *Int8ValueStruct) Set(i int8) {
+func (v *int8ValueStruct) Set(i int8) {
*v.addr.(*int8) = i
}
Type() Type;
}
-type Int16ValueStruct struct {
+type int16ValueStruct struct {
commonValue
}
-func Int16Creator(typ Type, addr Addr) Value {
- return &Int16ValueStruct{ commonValue{Int16Kind, typ, addr} }
+func int16Creator(typ Type, addr Addr) Value {
+ return &int16ValueStruct{ commonValue{Int16Kind, typ, addr} }
}
-func (v *Int16ValueStruct) Get() int16 {
+func (v *int16ValueStruct) Get() int16 {
return *v.addr.(*int16)
}
-func (v *Int16ValueStruct) Set(i int16) {
+func (v *int16ValueStruct) Set(i int16) {
*v.addr.(*int16) = i
}
Type() Type;
}
-type Int32ValueStruct struct {
+type int32ValueStruct struct {
commonValue
}
-func Int32Creator(typ Type, addr Addr) Value {
- return &Int32ValueStruct{ commonValue{Int32Kind, typ, addr} }
+func int32Creator(typ Type, addr Addr) Value {
+ return &int32ValueStruct{ commonValue{Int32Kind, typ, addr} }
}
-func (v *Int32ValueStruct) Get() int32 {
+func (v *int32ValueStruct) Get() int32 {
return *v.addr.(*int32)
}
-func (v *Int32ValueStruct) Set(i int32) {
+func (v *int32ValueStruct) Set(i int32) {
*v.addr.(*int32) = i
}
Type() Type;
}
-type Int64ValueStruct struct {
+type int64ValueStruct struct {
commonValue
}
-func Int64Creator(typ Type, addr Addr) Value {
- return &Int64ValueStruct{ commonValue{Int64Kind, typ, addr} }
+func int64Creator(typ Type, addr Addr) Value {
+ return &int64ValueStruct{ commonValue{Int64Kind, typ, addr} }
}
-func (v *Int64ValueStruct) Get() int64 {
+func (v *int64ValueStruct) Get() int64 {
return *v.addr.(*int64)
}
-func (v *Int64ValueStruct) Set(i int64) {
+func (v *int64ValueStruct) Set(i int64) {
*v.addr.(*int64) = i
}
Type() Type;
}
-type UintValueStruct struct {
+type uintValueStruct struct {
commonValue
}
-func UintCreator(typ Type, addr Addr) Value {
- return &UintValueStruct{ commonValue{UintKind, typ, addr} }
+func uintCreator(typ Type, addr Addr) Value {
+ return &uintValueStruct{ commonValue{UintKind, typ, addr} }
}
-func (v *UintValueStruct) Get() uint {
+func (v *uintValueStruct) Get() uint {
return *v.addr.(*uint)
}
-func (v *UintValueStruct) Set(i uint) {
+func (v *uintValueStruct) Set(i uint) {
*v.addr.(*uint) = i
}
Type() Type;
}
-type Uint8ValueStruct struct {
+type uint8ValueStruct struct {
commonValue
}
-func Uint8Creator(typ Type, addr Addr) Value {
- return &Uint8ValueStruct{ commonValue{Uint8Kind, typ, addr} }
+func uint8Creator(typ Type, addr Addr) Value {
+ return &uint8ValueStruct{ commonValue{Uint8Kind, typ, addr} }
}
-func (v *Uint8ValueStruct) Get() uint8 {
+func (v *uint8ValueStruct) Get() uint8 {
return *v.addr.(*uint8)
}
-func (v *Uint8ValueStruct) Set(i uint8) {
+func (v *uint8ValueStruct) Set(i uint8) {
*v.addr.(*uint8) = i
}
Type() Type;
}
-type Uint16ValueStruct struct {
+type uint16ValueStruct struct {
commonValue
}
-func Uint16Creator(typ Type, addr Addr) Value {
- return &Uint16ValueStruct{ commonValue{Uint16Kind, typ, addr} }
+func uint16Creator(typ Type, addr Addr) Value {
+ return &uint16ValueStruct{ commonValue{Uint16Kind, typ, addr} }
}
-func (v *Uint16ValueStruct) Get() uint16 {
+func (v *uint16ValueStruct) Get() uint16 {
return *v.addr.(*uint16)
}
-func (v *Uint16ValueStruct) Set(i uint16) {
+func (v *uint16ValueStruct) Set(i uint16) {
*v.addr.(*uint16) = i
}
Type() Type;
}
-type Uint32ValueStruct struct {
+type uint32ValueStruct struct {
commonValue
}
-func Uint32Creator(typ Type, addr Addr) Value {
- return &Uint32ValueStruct{ commonValue{Uint32Kind, typ, addr} }
+func uint32Creator(typ Type, addr Addr) Value {
+ return &uint32ValueStruct{ commonValue{Uint32Kind, typ, addr} }
}
-func (v *Uint32ValueStruct) Get() uint32 {
+func (v *uint32ValueStruct) Get() uint32 {
return *v.addr.(*uint32)
}
-func (v *Uint32ValueStruct) Set(i uint32) {
+func (v *uint32ValueStruct) Set(i uint32) {
*v.addr.(*uint32) = i
}
Type() Type;
}
-type Uint64ValueStruct struct {
+type uint64ValueStruct struct {
commonValue
}
-func Uint64Creator(typ Type, addr Addr) Value {
- return &Uint64ValueStruct{ commonValue{Uint64Kind, typ, addr} }
+func uint64Creator(typ Type, addr Addr) Value {
+ return &uint64ValueStruct{ commonValue{Uint64Kind, typ, addr} }
}
-func (v *Uint64ValueStruct) Get() uint64 {
+func (v *uint64ValueStruct) Get() uint64 {
return *v.addr.(*uint64)
}
-func (v *Uint64ValueStruct) Set(i uint64) {
+func (v *uint64ValueStruct) Set(i uint64) {
*v.addr.(*uint64) = i
}
Type() Type;
}
-type UintptrValueStruct struct {
+type uintptrValueStruct struct {
commonValue
}
-func UintptrCreator(typ Type, addr Addr) Value {
- return &UintptrValueStruct{ commonValue{UintptrKind, typ, addr} }
+func uintptrCreator(typ Type, addr Addr) Value {
+ return &uintptrValueStruct{ commonValue{UintptrKind, typ, addr} }
}
-func (v *UintptrValueStruct) Get() uintptr {
+func (v *uintptrValueStruct) Get() uintptr {
return *v.addr.(*uintptr)
}
-func (v *UintptrValueStruct) Set(i uintptr) {
+func (v *uintptrValueStruct) Set(i uintptr) {
*v.addr.(*uintptr) = i
}
Type() Type;
}
-type FloatValueStruct struct {
+type floatValueStruct struct {
commonValue
}
-func FloatCreator(typ Type, addr Addr) Value {
- return &FloatValueStruct{ commonValue{FloatKind, typ, addr} }
+func floatCreator(typ Type, addr Addr) Value {
+ return &floatValueStruct{ commonValue{FloatKind, typ, addr} }
}
-func (v *FloatValueStruct) Get() float {
+func (v *floatValueStruct) Get() float {
return *v.addr.(*float)
}
-func (v *FloatValueStruct) Set(f float) {
+func (v *floatValueStruct) Set(f float) {
*v.addr.(*float) = f
}
Type() Type;
}
-type Float32ValueStruct struct {
+type float32ValueStruct struct {
commonValue
}
-func Float32Creator(typ Type, addr Addr) Value {
- return &Float32ValueStruct{ commonValue{Float32Kind, typ, addr} }
+func float32Creator(typ Type, addr Addr) Value {
+ return &float32ValueStruct{ commonValue{Float32Kind, typ, addr} }
}
-func (v *Float32ValueStruct) Get() float32 {
+func (v *float32ValueStruct) Get() float32 {
return *v.addr.(*float32)
}
-func (v *Float32ValueStruct) Set(f float32) {
+func (v *float32ValueStruct) Set(f float32) {
*v.addr.(*float32) = f
}
Type() Type;
}
-type Float64ValueStruct struct {
+type float64ValueStruct struct {
commonValue
}
-func Float64Creator(typ Type, addr Addr) Value {
- return &Float64ValueStruct{ commonValue{Float64Kind, typ, addr} }
+func float64Creator(typ Type, addr Addr) Value {
+ return &float64ValueStruct{ commonValue{Float64Kind, typ, addr} }
}
-func (v *Float64ValueStruct) Get() float64 {
+func (v *float64ValueStruct) Get() float64 {
return *v.addr.(*float64)
}
-func (v *Float64ValueStruct) Set(f float64) {
+func (v *float64ValueStruct) Set(f float64) {
*v.addr.(*float64) = f
}
Type() Type;
}
-type Float80ValueStruct struct {
+type float80ValueStruct struct {
commonValue
}
-func Float80Creator(typ Type, addr Addr) Value {
- return &Float80ValueStruct{ commonValue{Float80Kind, typ, addr} }
+func float80Creator(typ Type, addr Addr) Value {
+ return &float80ValueStruct{ commonValue{Float80Kind, typ, addr} }
}
/*
Type() Type;
}
-type StringValueStruct struct {
+type stringValueStruct struct {
commonValue
}
-func StringCreator(typ Type, addr Addr) Value {
- return &StringValueStruct{ commonValue{StringKind, typ, addr} }
+func stringCreator(typ Type, addr Addr) Value {
+ return &stringValueStruct{ commonValue{StringKind, typ, addr} }
}
-func (v *StringValueStruct) Get() string {
+func (v *stringValueStruct) Get() string {
return *v.addr.(*string)
}
-func (v *StringValueStruct) Set(s string) {
+func (v *stringValueStruct) Set(s string) {
*v.addr.(*string) = s
}
Type() Type;
}
-type BoolValueStruct struct {
+type boolValueStruct struct {
commonValue
}
-func BoolCreator(typ Type, addr Addr) Value {
- return &BoolValueStruct{ commonValue{BoolKind, typ, addr} }
+func boolCreator(typ Type, addr Addr) Value {
+ return &boolValueStruct{ commonValue{BoolKind, typ, addr} }
}
-func (v *BoolValueStruct) Get() bool {
+func (v *boolValueStruct) Get() bool {
return *v.addr.(*bool)
}
-func (v *BoolValueStruct) Set(b bool) {
+func (v *boolValueStruct) Set(b bool) {
*v.addr.(*bool) = b
}
SetSub(Value);
}
-type PtrValueStruct struct {
+type ptrValueStruct struct {
commonValue
}
-func (v *PtrValueStruct) Get() Addr {
+func (v *ptrValueStruct) Get() Addr {
return *v.addr.(*Addr)
}
-func (v *PtrValueStruct) Sub() Value {
- return NewValueAddr(v.typ.(PtrType).Sub(), v.Get());
+func (v *ptrValueStruct) Sub() Value {
+ return newValueAddr(v.typ.(PtrType).Sub(), v.Get());
}
-func (v *PtrValueStruct) SetSub(subv Value) {
+func (v *ptrValueStruct) SetSub(subv Value) {
a := v.typ.(PtrType).Sub();
b := subv.Type();
- if !EqualType(a, b) {
+ if !equalType(a, b) {
panicln("reflect: incompatible types in PtrValue.SetSub:",
a.String(), b.String());
}
*v.addr.(*Addr) = subv.Addr();
}
-func PtrCreator(typ Type, addr Addr) Value {
- return &PtrValueStruct{ commonValue{PtrKind, typ, addr} };
+func ptrCreator(typ Type, addr Addr) Value {
+ return &ptrValueStruct{ commonValue{PtrKind, typ, addr} };
}
// -- Array
uint32 cap;
};
*/
-type RuntimeArray struct {
+type runtimeArray struct {
data Addr;
len uint32;
cap uint32;
}
-type OpenArrayValueStruct struct {
+type openArrayValueStruct struct {
commonValue;
elemtype Type;
elemsize int;
- array *RuntimeArray;
+ array *runtimeArray;
}
-func (v *OpenArrayValueStruct) Open() bool {
+func (v *openArrayValueStruct) Open() bool {
return true
}
-func (v *OpenArrayValueStruct) Len() int {
+func (v *openArrayValueStruct) Len() int {
return int(v.array.len);
}
-func (v *OpenArrayValueStruct) Cap() int {
+func (v *openArrayValueStruct) Cap() int {
return int(v.array.cap);
}
-func (v *OpenArrayValueStruct) SetLen(len int) {
+func (v *openArrayValueStruct) SetLen(len int) {
if len > v.Cap() {
panicln("reflect: OpenArrayValueStruct.SetLen", len, v.Cap());
}
v.array.len = uint32(len);
}
-func (v *OpenArrayValueStruct) Elem(i int) Value {
+func (v *openArrayValueStruct) Elem(i int) Value {
data_uint := uintptr(v.array.data) + uintptr(i * v.elemsize);
- return NewValueAddr(v.elemtype, Addr(data_uint));
+ return newValueAddr(v.elemtype, Addr(data_uint));
}
-type FixedArrayValueStruct struct {
+type fixedArrayValueStruct struct {
commonValue;
elemtype Type;
elemsize int;
len int;
}
-func (v *FixedArrayValueStruct) Open() bool {
+func (v *fixedArrayValueStruct) Open() bool {
return false
}
-func (v *FixedArrayValueStruct) Len() int {
+func (v *fixedArrayValueStruct) Len() int {
return v.len
}
-func (v *FixedArrayValueStruct) Cap() int {
+func (v *fixedArrayValueStruct) Cap() int {
return v.len
}
-func (v *FixedArrayValueStruct) SetLen(len int) {
+func (v *fixedArrayValueStruct) SetLen(len int) {
}
-func (v *FixedArrayValueStruct) Elem(i int) Value {
+func (v *fixedArrayValueStruct) Elem(i int) Value {
data_uint := uintptr(v.addr) + uintptr(i * v.elemsize);
- return NewValueAddr(v.elemtype, Addr(data_uint));
+ return newValueAddr(v.elemtype, Addr(data_uint));
return nil
}
-func ArrayCreator(typ Type, addr Addr) Value {
+func arrayCreator(typ Type, addr Addr) Value {
arraytype := typ.(ArrayType);
if arraytype.Open() {
- v := new(OpenArrayValueStruct);
+ v := new(openArrayValueStruct);
v.kind = ArrayKind;
v.addr = addr;
v.typ = typ;
v.elemtype = arraytype.Elem();
v.elemsize = v.elemtype.Size();
- v.array = addr.(*RuntimeArray);
+ v.array = addr.(*runtimeArray);
return v;
}
- v := new(FixedArrayValueStruct);
+ v := new(fixedArrayValueStruct);
v.kind = ArrayKind;
v.addr = addr;
v.typ = typ;
Elem(key Value) Value;
}
-type MapValueStruct struct {
+type mapValueStruct struct {
commonValue
}
-func MapCreator(typ Type, addr Addr) Value {
- return &MapValueStruct{ commonValue{MapKind, typ, addr} }
+func mapCreator(typ Type, addr Addr) Value {
+ return &mapValueStruct{ commonValue{MapKind, typ, addr} }
}
-func (v *MapValueStruct) Len() int {
+func (v *mapValueStruct) Len() int {
return 0 // TODO: probably want this to be dynamic
}
-func (v *MapValueStruct) Elem(key Value) Value {
+func (v *mapValueStruct) Elem(key Value) Value {
panic("map value element");
return nil
}
Type() Type;
}
-type ChanValueStruct struct {
+type chanValueStruct struct {
commonValue
}
-func ChanCreator(typ Type, addr Addr) Value {
- return &ChanValueStruct{ commonValue{ChanKind, typ, addr} }
+func chanCreator(typ Type, addr Addr) Value {
+ return &chanValueStruct{ commonValue{ChanKind, typ, addr} }
}
// -- Struct
Field(i int) Value;
}
-type StructValueStruct struct {
+type structValueStruct struct {
commonValue;
field []Value;
}
-func (v *StructValueStruct) Len() int {
+func (v *structValueStruct) Len() int {
return len(v.field)
}
-func (v *StructValueStruct) Field(i int) Value {
+func (v *structValueStruct) Field(i int) Value {
return v.field[i]
}
-func StructCreator(typ Type, addr Addr) Value {
+func structCreator(typ Type, addr Addr) Value {
t := typ.(StructType);
nfield := t.Len();
- v := &StructValueStruct{ commonValue{StructKind, typ, addr}, make([]Value, nfield) };
+ v := &structValueStruct{ commonValue{StructKind, typ, addr}, make([]Value, nfield) };
for i := 0; i < nfield; i++ {
name, ftype, str, offset := t.Field(i);
addr_uint := uintptr(addr) + uintptr(offset);
- v.field[i] = NewValueAddr(ftype, Addr(addr_uint));
+ v.field[i] = newValueAddr(ftype, Addr(addr_uint));
}
v.typ = typ;
return v;
Get() interface {};
}
-type InterfaceValueStruct struct {
+type interfaceValueStruct struct {
commonValue
}
-func (v *InterfaceValueStruct) Get() interface{} {
+func (v *interfaceValueStruct) Get() interface{} {
return *v.addr.(*interface{})
}
-func InterfaceCreator(typ Type, addr Addr) Value {
- return &InterfaceValueStruct{ commonValue{InterfaceKind, typ, addr} }
+func interfaceCreator(typ Type, addr Addr) Value {
+ return &interfaceValueStruct{ commonValue{InterfaceKind, typ, addr} }
}
// -- Func
Type() Type;
}
-type FuncValueStruct struct {
+type funcValueStruct struct {
commonValue
}
-func FuncCreator(typ Type, addr Addr) Value {
- return &FuncValueStruct{ commonValue{FuncKind, typ, addr} }
-}
-
-var creator = map[int] Creator {
- MissingKind : &MissingCreator,
- IntKind : &IntCreator,
- Int8Kind : &Int8Creator,
- Int16Kind : &Int16Creator,
- Int32Kind : &Int32Creator,
- Int64Kind : &Int64Creator,
- UintKind : &UintCreator,
- Uint8Kind : &Uint8Creator,
- Uint16Kind : &Uint16Creator,
- Uint32Kind : &Uint32Creator,
- Uint64Kind : &Uint64Creator,
- UintptrKind : &UintptrCreator,
- FloatKind : &FloatCreator,
- Float32Kind : &Float32Creator,
- Float64Kind : &Float64Creator,
- Float80Kind : &Float80Creator,
- StringKind : &StringCreator,
- BoolKind : &BoolCreator,
- PtrKind : &PtrCreator,
- ArrayKind : &ArrayCreator,
- MapKind : &MapCreator,
- ChanKind : &ChanCreator,
- StructKind : &StructCreator,
- InterfaceKind : &InterfaceCreator,
- FuncKind : &FuncCreator,
+func funcCreator(typ Type, addr Addr) Value {
+ return &funcValueStruct{ commonValue{FuncKind, typ, addr} }
+}
+
+var creator = map[int] creatorFn {
+ MissingKind : &missingCreator,
+ IntKind : &intCreator,
+ Int8Kind : &int8Creator,
+ Int16Kind : &int16Creator,
+ Int32Kind : &int32Creator,
+ Int64Kind : &int64Creator,
+ UintKind : &uintCreator,
+ Uint8Kind : &uint8Creator,
+ Uint16Kind : &uint16Creator,
+ Uint32Kind : &uint32Creator,
+ Uint64Kind : &uint64Creator,
+ UintptrKind : &uintptrCreator,
+ FloatKind : &floatCreator,
+ Float32Kind : &float32Creator,
+ Float64Kind : &float64Creator,
+ Float80Kind : &float80Creator,
+ StringKind : &stringCreator,
+ BoolKind : &boolCreator,
+ PtrKind : &ptrCreator,
+ ArrayKind : &arrayCreator,
+ MapKind : &mapCreator,
+ ChanKind : &chanCreator,
+ StructKind : &structCreator,
+ InterfaceKind : &interfaceCreator,
+ FuncKind : &funcCreator,
}
var typecache = make(map[string] Type);
-func NewValueAddr(typ Type, addr Addr) Value {
+func newValueAddr(typ Type, addr Addr) Value {
c, ok := creator[typ.Kind()];
if !ok {
panicln("no creator for type" , typ.Kind());
size = 1;
}
data := make([]uint8, size);
- return NewValueAddr(typ, Addr(&data[0]));
+ return newValueAddr(typ, Addr(&data[0]));
}
/*
return nil
}
- array := new(RuntimeArray);
+ array := new(runtimeArray);
size := typ.Elem().Size() * cap;
if size == 0 {
size = 1;
array.len = uint32(len);
array.cap = uint32(cap);
- return NewValueAddr(typ, Addr(array));
+ return newValueAddr(typ, Addr(array));
}
export func CopyArray(dst ArrayValue, src ArrayValue, n int) {
}
dt := dst.Type().(ArrayType).Elem();
st := src.Type().(ArrayType).Elem();
- if !EqualType(dt, st) {
+ if !equalType(dt, st) {
panicln("reflect: incompatible types in CopyArray:",
dt.String(), st.String());
}
if indir {
// Content of interface is a pointer.
- return NewValueAddr(typ, value.(uintptr).(Addr));
+ return newValueAddr(typ, value.(uintptr).(Addr));
}
// Content of interface is a value;
// need a permanent copy to take its address.
ap := new(uint64);
*ap = value;
- return NewValueAddr(typ, ap.(Addr));
+ return newValueAddr(typ, ap.(Addr));
}