Fix is to move all decoder state into the decoder object.
Fixes #215.
R=rsc
CC=golang-dev
https://golang.org/cl/155077
EncodeT{1 << 63, []byte{0xF8, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
}
-
// Test basic encode/decode routines for unsigned integers
func TestUintCodec(t *testing.T) {
b := new(bytes.Buffer);
t: &T2{"this is T2"},
};
b := new(bytes.Buffer);
- encode(b, t1);
+ err := NewEncoder(b).Encode(t1);
+ if err != nil {
+ t.Error("encode:", err)
+ }
var _t1 T1;
- decode(b, getTypeInfoNoError(reflect.Typeof(_t1)).id, &_t1);
+ err = NewDecoder(b).Decode(&_t1);
+ if err != nil {
+ t.Fatal("decode:", err)
+ }
if !reflect.DeepEqual(t1, &_t1) {
t.Errorf("encode expected %v got %v", *t1, _t1)
}
}
var it inputT;
var err os.Error;
- id := getTypeInfoNoError(reflect.Typeof(it)).id;
b := new(bytes.Buffer);
+ enc := NewEncoder(b);
+ dec := NewDecoder(b);
// int8
b.Reset();
mini int8;
}
var o1 outi8;
- encode(b, it);
- err = decode(b, id, &o1);
+ enc.Encode(it);
+ err = dec.Decode(&o1);
if err == nil || err.String() != `value for "maxi" out of range` {
t.Error("wrong overflow error for int8:", err)
}
mini: math.MinInt8 - 1,
};
b.Reset();
- encode(b, it);
- err = decode(b, id, &o1);
+ enc.Encode(it);
+ err = dec.Decode(&o1);
if err == nil || err.String() != `value for "mini" out of range` {
t.Error("wrong underflow error for int8:", err)
}
mini int16;
}
var o2 outi16;
- encode(b, it);
- err = decode(b, id, &o2);
+ enc.Encode(it);
+ err = dec.Decode(&o2);
if err == nil || err.String() != `value for "maxi" out of range` {
t.Error("wrong overflow error for int16:", err)
}
mini: math.MinInt16 - 1,
};
b.Reset();
- encode(b, it);
- err = decode(b, id, &o2);
+ enc.Encode(it);
+ err = dec.Decode(&o2);
if err == nil || err.String() != `value for "mini" out of range` {
t.Error("wrong underflow error for int16:", err)
}
mini int32;
}
var o3 outi32;
- encode(b, it);
- err = decode(b, id, &o3);
+ enc.Encode(it);
+ err = dec.Decode(&o3);
if err == nil || err.String() != `value for "maxi" out of range` {
t.Error("wrong overflow error for int32:", err)
}
mini: math.MinInt32 - 1,
};
b.Reset();
- encode(b, it);
- err = decode(b, id, &o3);
+ enc.Encode(it);
+ err = dec.Decode(&o3);
if err == nil || err.String() != `value for "mini" out of range` {
t.Error("wrong underflow error for int32:", err)
}
maxu uint8;
}
var o4 outu8;
- encode(b, it);
- err = decode(b, id, &o4);
+ enc.Encode(it);
+ err = dec.Decode(&o4);
if err == nil || err.String() != `value for "maxu" out of range` {
t.Error("wrong overflow error for uint8:", err)
}
maxu uint16;
}
var o5 outu16;
- encode(b, it);
- err = decode(b, id, &o5);
+ enc.Encode(it);
+ err = dec.Decode(&o5);
if err == nil || err.String() != `value for "maxu" out of range` {
t.Error("wrong overflow error for uint16:", err)
}
maxu uint32;
}
var o6 outu32;
- encode(b, it);
- err = decode(b, id, &o6);
+ enc.Encode(it);
+ err = dec.Decode(&o6);
if err == nil || err.String() != `value for "maxu" out of range` {
t.Error("wrong overflow error for uint32:", err)
}
minf float32;
}
var o7 outf32;
- encode(b, it);
- err = decode(b, id, &o7);
+ enc.Encode(it);
+ err = dec.Decode(&o7);
if err == nil || err.String() != `value for "maxf" out of range` {
t.Error("wrong overflow error for float32:", err)
}
rt.next = new(RT);
rt.next.a = "level2";
b := new(bytes.Buffer);
- encode(b, rt);
+ NewEncoder(b).Encode(rt);
var drt RT;
- decode(b, getTypeInfoNoError(reflect.Typeof(drt)).id, &drt);
+ dec := NewDecoder(b);
+ err := dec.Decode(&drt);
+ if err != nil {
+ t.Errorf("decoder error:", err)
+ }
if drt.a != rt.a {
t.Errorf("nesting: encode expected %v got %v", *rt, drt)
}
**t1.d = new(int);
***t1.d = 17777;
b := new(bytes.Buffer);
- encode(b, t1);
+ enc := NewEncoder(b);
+ enc.Encode(t1);
+ dec := NewDecoder(b);
var t0 T0;
- t0Id := getTypeInfoNoError(reflect.Typeof(t0)).id;
- decode(b, t0Id, &t0);
+ dec.Decode(&t0);
if t0.a != 17 || t0.b != 177 || t0.c != 1777 || t0.d != 17777 {
t.Errorf("t1->t0: expected {17 177 1777 17777}; got %v", t0)
}
**t2.a = new(int);
***t2.a = 17;
b.Reset();
- encode(b, t2);
+ enc.Encode(t2);
t0 = T0{};
- decode(b, t0Id, &t0);
+ dec.Decode(&t0);
if t0.a != 17 || t0.b != 177 || t0.c != 1777 || t0.d != 17777 {
t.Errorf("t2->t0 expected {17 177 1777 17777}; got %v", t0)
}
// Now transfer t0 into t1
t0 = T0{17, 177, 1777, 17777};
b.Reset();
- encode(b, t0);
+ enc.Encode(t0);
t1 = T1{};
- t1Id := getTypeInfoNoError(reflect.Typeof(t1)).id;
- decode(b, t1Id, &t1);
+ dec.Decode(&t1);
if t1.a != 17 || *t1.b != 177 || **t1.c != 1777 || ***t1.d != 17777 {
t.Errorf("t0->t1 expected {17 177 1777 17777}; got {%d %d %d %d}", t1.a, *t1.b, **t1.c, ***t1.d)
}
// Now transfer t0 into t2
b.Reset();
- encode(b, t0);
+ enc.Encode(t0);
t2 = T2{};
- t2Id := getTypeInfoNoError(reflect.Typeof(t2)).id;
- decode(b, t2Id, &t2);
+ dec.Decode(&t2);
if ***t2.a != 17 || **t2.b != 177 || *t2.c != 1777 || t2.d != 17777 {
t.Errorf("t0->t2 expected {17 177 1777 17777}; got {%d %d %d %d}", ***t2.a, **t2.b, *t2.c, t2.d)
}
// Now do t2 again but without pre-allocated pointers.
b.Reset();
- encode(b, t0);
+ enc.Encode(t0);
***t2.a = 0;
**t2.b = 0;
*t2.c = 0;
t2.d = 0;
- decode(b, t2Id, &t2);
+ dec.Decode(&t2);
if ***t2.a != 17 || **t2.b != 177 || *t2.c != 1777 || t2.d != 17777 {
t.Errorf("t0->t2 expected {17 177 1777 17777}; got {%d %d %d %d}", ***t2.a, **t2.b, *t2.c, t2.d)
}
rt0.b = "hello";
rt0.c = 3.14159;
b := new(bytes.Buffer);
- encode(b, rt0);
- rt0Id := getTypeInfoNoError(reflect.Typeof(rt0)).id;
+ NewEncoder(b).Encode(rt0);
+ dec := NewDecoder(b);
var rt1 RT1;
// Wire type is RT0, local type is RT1.
- decode(b, rt0Id, &rt1);
+ err := dec.Decode(&rt1);
+ if err != nil {
+ t.Error("decode error:", err)
+ }
if rt0.a != rt1.a || rt0.b != rt1.b || rt0.c != rt1.c {
t.Errorf("rt1->rt0: expected %v; got %v", rt0, rt1)
}
it0.ignore_i = &RT1{3.1, "hi", 7, "hello"};
b := new(bytes.Buffer);
- encode(b, it0);
- rt0Id := getTypeInfoNoError(reflect.Typeof(it0)).id;
+ NewEncoder(b).Encode(it0);
+ dec := NewDecoder(b);
var rt1 RT1;
// Wire type is IT0, local type is RT1.
- err := decode(b, rt0Id, &rt1);
+ err := dec.Decode(&rt1);
if err != nil {
t.Error("error: ", err)
}
// Execution engine
// The encoder engine is an array of instructions indexed by field number of the incoming
-// data. It is executed with random access according to field number.
+// decoder. It is executed with random access according to field number.
type decEngine struct {
instr []decInstr;
numInstr int; // the number of active instructions
// Return the decoding op for the base type under rt and
// the indirection count to reach it.
-func decOpFor(wireId typeId, rt reflect.Type, name string) (decOp, int, os.Error) {
+func (dec *Decoder) decOpFor(wireId typeId, rt reflect.Type, name string) (decOp, int, os.Error) {
typ, indir := indirect(rt);
op, ok := decOpMap[reflect.Typeof(typ)];
if !ok {
break;
}
elemId := wireId.gobType().(*sliceType).Elem;
- elemOp, elemIndir, err := decOpFor(elemId, t.Elem(), name);
+ elemOp, elemIndir, err := dec.decOpFor(elemId, t.Elem(), name);
if err != nil {
return nil, 0, err
}
case *reflect.ArrayType:
name = "element of " + name;
elemId := wireId.gobType().(*arrayType).Elem;
- elemOp, elemIndir, err := decOpFor(elemId, t.Elem(), name);
+ elemOp, elemIndir, err := dec.decOpFor(elemId, t.Elem(), name);
if err != nil {
return nil, 0, err
}
case *reflect.StructType:
// Generate a closure that calls out to the engine for the nested type.
- enginePtr, err := getDecEnginePtr(wireId, typ);
+ enginePtr, err := dec.getDecEnginePtr(wireId, typ);
if err != nil {
return nil, 0, err
}
}
// Return the decoding op for a field that has no destination.
-func decIgnoreOpFor(wireId typeId) (decOp, os.Error) {
+func (dec *Decoder) decIgnoreOpFor(wireId typeId) (decOp, os.Error) {
op, ok := decIgnoreOpMap[wireId];
if !ok {
// Special cases
switch t := wireId.gobType().(type) {
case *sliceType:
elemId := wireId.gobType().(*sliceType).Elem;
- elemOp, err := decIgnoreOpFor(elemId);
+ elemOp, err := dec.decIgnoreOpFor(elemId);
if err != nil {
return nil, err
}
case *arrayType:
elemId := wireId.gobType().(*arrayType).Elem;
- elemOp, err := decIgnoreOpFor(elemId);
+ elemOp, err := dec.decIgnoreOpFor(elemId);
if err != nil {
return nil, err
}
case *structType:
// Generate a closure that calls out to the engine for the nested type.
- enginePtr, err := getIgnoreEnginePtr(wireId);
+ enginePtr, err := dec.getIgnoreEnginePtr(wireId);
if err != nil {
return nil, err
}
return true;
}
-func compileDec(wireId typeId, rt reflect.Type) (engine *decEngine, err os.Error) {
+func (dec *Decoder) compileDec(remoteId typeId, rt reflect.Type) (engine *decEngine, err os.Error) {
srt, ok1 := rt.(*reflect.StructType);
- wireStruct, ok2 := wireId.gobType().(*structType);
- if !ok1 || !ok2 {
- return nil, errNotStruct
+ var wireStruct *structType;
+ // Builtin types can come from global pool; the rest must be defined by the decoder
+ if t, ok := builtinIdToType[remoteId]; ok {
+ wireStruct = t.(*structType)
+ } else {
+ w, ok2 := dec.wireType[remoteId];
+ if !ok1 || !ok2 {
+ return nil, errNotStruct
+ }
+ wireStruct = w.s;
}
engine = new(decEngine);
engine.instr = make([]decInstr, len(wireStruct.field));
ovfl := overflow(wireField.name);
// TODO(r): anonymous names
if !present {
- op, err := decIgnoreOpFor(wireField.id);
+ op, err := dec.decIgnoreOpFor(wireField.id);
if err != nil {
return nil, err
}
continue;
}
if !compatibleType(localField.Type, wireField.id) {
- details := " (" + wireField.id.String() + " incompatible with " + localField.Type.String() + ") in type " + wireId.Name();
+ details := " (" + wireField.id.String() + " incompatible with " + localField.Type.String() + ") in type " + remoteId.Name();
return nil, os.ErrorString("gob: wrong type for field " + wireField.name + details);
}
- op, indir, err := decOpFor(wireField.id, localField.Type, localField.Name);
+ op, indir, err := dec.decOpFor(wireField.id, localField.Type, localField.Name);
if err != nil {
return nil, err
}
return;
}
-var decoderCache = make(map[reflect.Type]map[typeId]**decEngine)
-var ignorerCache = make(map[typeId]**decEngine)
-
-// typeLock must be held.
-func getDecEnginePtr(wireId typeId, rt reflect.Type) (enginePtr **decEngine, err os.Error) {
- decoderMap, ok := decoderCache[rt];
+func (dec *Decoder) getDecEnginePtr(remoteId typeId, rt reflect.Type) (enginePtr **decEngine, err os.Error) {
+ decoderMap, ok := dec.decoderCache[rt];
if !ok {
decoderMap = make(map[typeId]**decEngine);
- decoderCache[rt] = decoderMap;
+ dec.decoderCache[rt] = decoderMap;
}
- if enginePtr, ok = decoderMap[wireId]; !ok {
+ if enginePtr, ok = decoderMap[remoteId]; !ok {
// To handle recursive types, mark this engine as underway before compiling.
enginePtr = new(*decEngine);
- decoderMap[wireId] = enginePtr;
- *enginePtr, err = compileDec(wireId, rt);
+ decoderMap[remoteId] = enginePtr;
+ *enginePtr, err = dec.compileDec(remoteId, rt);
if err != nil {
- decoderMap[wireId] = nil, false
+ decoderMap[remoteId] = nil, false
}
}
return;
var emptyStructType = reflect.Typeof(emptyStruct{})
-// typeLock must be held.
-func getIgnoreEnginePtr(wireId typeId) (enginePtr **decEngine, err os.Error) {
+func (dec *Decoder) getIgnoreEnginePtr(wireId typeId) (enginePtr **decEngine, err os.Error) {
var ok bool;
- if enginePtr, ok = ignorerCache[wireId]; !ok {
+ if enginePtr, ok = dec.ignorerCache[wireId]; !ok {
// To handle recursive types, mark this engine as underway before compiling.
enginePtr = new(*decEngine);
- ignorerCache[wireId] = enginePtr;
- *enginePtr, err = compileDec(wireId, emptyStructType);
+ dec.ignorerCache[wireId] = enginePtr;
+ *enginePtr, err = dec.compileDec(wireId, emptyStructType);
if err != nil {
- ignorerCache[wireId] = nil, false
+ dec.ignorerCache[wireId] = nil, false
}
}
return;
}
-func decode(b *bytes.Buffer, wireId typeId, e interface{}) os.Error {
+func (dec *Decoder) decode(wireId typeId, e interface{}) os.Error {
// Dereference down to the underlying struct type.
rt, indir := indirect(reflect.Typeof(e));
st, ok := rt.(*reflect.StructType);
if !ok {
return os.ErrorString("gob: decode can't handle " + rt.String())
}
- typeLock.Lock();
- if _, ok := idToType[wireId]; !ok {
- typeLock.Unlock();
- return errBadType;
- }
- enginePtr, err := getDecEnginePtr(wireId, rt);
- typeLock.Unlock();
+ enginePtr, err := dec.getDecEnginePtr(wireId, rt);
if err != nil {
return err
}
name := rt.Name();
return os.ErrorString("gob: type mismatch: no fields matched compiling decoder for " + name);
}
- return decodeStruct(engine, st, b, uintptr(reflect.NewValue(e).Addr()), indir);
+ return decodeStruct(engine, st, dec.state.b, uintptr(reflect.NewValue(e).Addr()), indir);
}
func init() {
"bytes";
"io";
"os";
+ "reflect";
"sync";
)
// A Decoder manages the receipt of type and data information read from the
// remote side of a connection.
type Decoder struct {
- mutex sync.Mutex; // each item must be received atomically
- r io.Reader; // source of the data
- seen map[typeId]*wireType; // which types we've already seen described
- state *decodeState; // reads data from in-memory buffer
- countState *decodeState; // reads counts from wire
+ mutex sync.Mutex; // each item must be received atomically
+ r io.Reader; // source of the data
+ wireType map[typeId]*wireType; // map from remote ID to local description
+ decoderCache map[reflect.Type]map[typeId]**decEngine; // cache of compiled engines
+ ignorerCache map[typeId]**decEngine; // ditto for ignored objects
+ state *decodeState; // reads data from in-memory buffer
+ countState *decodeState; // reads counts from wire
buf []byte;
oneByte []byte;
}
func NewDecoder(r io.Reader) *Decoder {
dec := new(Decoder);
dec.r = r;
- dec.seen = make(map[typeId]*wireType);
+ dec.wireType = make(map[typeId]*wireType);
dec.state = newDecodeState(nil); // buffer set in Decode(); rest is unimportant
+ dec.decoderCache = make(map[reflect.Type]map[typeId]**decEngine);
+ dec.ignorerCache = make(map[typeId]**decEngine);
dec.oneByte = make([]byte, 1);
return dec;
func (dec *Decoder) recvType(id typeId) {
// Have we already seen this type? That's an error
- if _, alreadySeen := dec.seen[id]; alreadySeen {
+ if _, alreadySeen := dec.wireType[id]; alreadySeen {
dec.state.err = os.ErrorString("gob: duplicate type received");
return;
}
// Type:
wire := new(wireType);
- decode(dec.state.b, tWireType, wire);
+ dec.state.err = dec.decode(tWireType, wire);
// Remember we've seen this type.
- dec.seen[id] = wire;
+ dec.wireType[id] = wire;
}
// Decode reads the next value from the connection and stores
}
// No, it's a value.
- dec.state.err = decode(dec.state.b, id, e);
+ // Make sure the type has been defined already.
+ _, ok := dec.wireType[id];
+ if !ok {
+ dec.state.err = errBadType;
+ break;
+ }
+ dec.state.err = dec.decode(id, e);
break;
}
return dec.state.err;
enc.w.Write(enc.buf[0:total]);
}
-func (enc *Encoder) sendType(origt reflect.Type, topLevel bool) {
+func (enc *Encoder) sendType(origt reflect.Type) {
// Drill down to the base type.
rt, _ := indirect(origt);
// We only send structs - everything else is basic or an error
- switch rt.(type) {
+ switch rt := rt.(type) {
default:
- // Basic types do not need to be described, but if this is a top-level
- // type, it's a user error, at least for now.
- if topLevel {
- enc.badType(rt)
- }
- return;
+ // Basic types do not need to be described.
+ return
case *reflect.StructType:
// Structs do need to be described.
break
// Probably a bad field in a struct.
enc.badType(rt);
return;
- case *reflect.ArrayType, *reflect.SliceType:
- // Array and slice types are not sent, only their element types.
- // If we see one here it's user error; probably a bad top-level value.
- enc.badType(rt);
+ // Array and slice types are not sent, only their element types.
+ case reflect.ArrayOrSliceType:
+ enc.sendType(rt.Elem());
return;
}
// Now send the inner types
st := rt.(*reflect.StructType);
for i := 0; i < st.NumField(); i++ {
- enc.sendType(st.Field(i).Type, false)
+ enc.sendType(st.Field(i).Type)
}
return;
}
panicln("Encoder: buffer not empty")
}
rt, _ := indirect(reflect.Typeof(e));
+ // Must be a struct
+ if _, ok := rt.(*reflect.StructType); !ok {
+ enc.badType(rt);
+ return enc.state.err;
+ }
+
// Make sure we're single-threaded through here.
enc.mutex.Lock();
// First, have we already sent this type?
if _, alreadySent := enc.sent[rt]; !alreadySent {
// No, so send it.
- enc.sendType(rt, true);
+ enc.sendType(rt);
if enc.state.err != nil {
enc.state.b.Reset();
enc.countState.b.Reset();
// Like ET1 but with a different type for a field
type ET4 struct {
a int;
- et2 *ET1;
+ et2 float;
next int;
}
-func TestBasicEncoder(t *testing.T) {
- b := new(bytes.Buffer);
- enc := NewEncoder(b);
- et1 := new(ET1);
- et1.a = 7;
- et1.et2 = new(ET2);
- enc.Encode(et1);
- if enc.state.err != nil {
- t.Error("encoder fail:", enc.state.err)
- }
-
- // Decode the result by hand to verify;
- state := newDecodeState(b);
- // The output should be:
- // 0) The length, 38.
- length := decodeUint(state);
- if length != 38 {
- t.Fatal("0. expected length 38; got", length)
- }
- // 1) -7: the type id of ET1
- id1 := decodeInt(state);
- if id1 >= 0 {
- t.Fatal("expected ET1 negative id; got", id1)
- }
- // 2) The wireType for ET1
- wire1 := new(wireType);
- err := decode(b, tWireType, wire1);
- if err != nil {
- t.Fatal("error decoding ET1 type:", err)
- }
- info := getTypeInfoNoError(reflect.Typeof(ET1{}));
- trueWire1 := &wireType{s: info.id.gobType().(*structType)};
- if !reflect.DeepEqual(wire1, trueWire1) {
- t.Fatalf("invalid wireType for ET1: expected %+v; got %+v\n", *trueWire1, *wire1)
- }
- // 3) The length, 21.
- length = decodeUint(state);
- if length != 21 {
- t.Fatal("3. expected length 21; got", length)
- }
- // 4) -8: the type id of ET2
- id2 := decodeInt(state);
- if id2 >= 0 {
- t.Fatal("expected ET2 negative id; got", id2)
- }
- // 5) The wireType for ET2
- wire2 := new(wireType);
- err = decode(b, tWireType, wire2);
- if err != nil {
- t.Fatal("error decoding ET2 type:", err)
- }
- info = getTypeInfoNoError(reflect.Typeof(ET2{}));
- trueWire2 := &wireType{s: info.id.gobType().(*structType)};
- if !reflect.DeepEqual(wire2, trueWire2) {
- t.Fatalf("invalid wireType for ET2: expected %+v; got %+v\n", *trueWire2, *wire2)
- }
- // 6) The length, 6.
- length = decodeUint(state);
- if length != 6 {
- t.Fatal("6. expected length 6; got", length)
- }
- // 7) The type id for the et1 value
- newId1 := decodeInt(state);
- if newId1 != -id1 {
- t.Fatal("expected Et1 id", -id1, "got", newId1)
- }
- // 8) The value of et1
- newEt1 := new(ET1);
- et1Id := getTypeInfoNoError(reflect.Typeof(*newEt1)).id;
- err = decode(b, et1Id, newEt1);
- if err != nil {
- t.Fatal("error decoding ET1 value:", err)
- }
- if !reflect.DeepEqual(et1, newEt1) {
- t.Fatalf("invalid data for et1: expected %+v; got %+v\n", *et1, *newEt1)
- }
- // 9) EOF
- if b.Len() != 0 {
- t.Error("not at eof;", b.Len(), "bytes left")
- }
-
- // Now do it again. This time we should see only the type id and value.
- b.Reset();
- enc.Encode(et1);
- if enc.state.err != nil {
- t.Error("2nd round: encoder fail:", enc.state.err)
- }
- // The length.
- length = decodeUint(state);
- if length != 6 {
- t.Fatal("6. expected length 6; got", length)
- }
- // 5a) The type id for the et1 value
- newId1 = decodeInt(state);
- if newId1 != -id1 {
- t.Fatal("2nd round: expected Et1 id", -id1, "got", newId1)
- }
- // 6a) The value of et1
- newEt1 = new(ET1);
- err = decode(b, et1Id, newEt1);
- if err != nil {
- t.Fatal("2nd round: error decoding ET1 value:", err)
- }
- if !reflect.DeepEqual(et1, newEt1) {
- t.Fatalf("2nd round: invalid data for et1: expected %+v; got %+v\n", *et1, *newEt1)
- }
- // 7a) EOF
- if b.Len() != 0 {
- t.Error("2nd round: not at eof;", b.Len(), "bytes left")
- }
-}
-
func TestEncoderDecoder(t *testing.T) {
b := new(bytes.Buffer);
enc := NewEncoder(b);
t.Error("expected error for", msg)
}
if !shouldFail && (dec.state.err != nil) {
- t.Error("unexpected error for", msg)
+ t.Error("unexpected error for", msg, dec.state.err)
}
}
var types = make(map[reflect.Type]gobType)
var idToType = make(map[typeId]gobType)
+var builtinIdToType map[typeId]gobType // set in init() after builtins are established
func setTypeId(typ gobType) {
nextId++;
checkId(8, getTypeInfoNoError(reflect.Typeof(structType{})).id);
checkId(9, getTypeInfoNoError(reflect.Typeof(commonType{})).id);
checkId(10, getTypeInfoNoError(reflect.Typeof(fieldType{})).id);
+ builtinIdToType = make(map[typeId]gobType);
+ for k, v := range idToType {
+ builtinIdToType[k] = v
+ }
}
// Array type