| // Copyright 2015 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. |
| |
| // This file is a copy of $GOROOT/src/go/internal/gcimporter/bimport.go. |
| |
| package gcimporter |
| |
| import ( |
| "encoding/binary" |
| "fmt" |
| "go/constant" |
| "go/token" |
| "go/types" |
| "sort" |
| "strconv" |
| "strings" |
| "sync" |
| "unicode" |
| "unicode/utf8" |
| ) |
| |
| type importer struct { |
| imports map[string]*types.Package |
| data []byte |
| importpath string |
| buf []byte // for reading strings |
| version int // export format version |
| |
| // object lists |
| strList []string // in order of appearance |
| pathList []string // in order of appearance |
| pkgList []*types.Package // in order of appearance |
| typList []types.Type // in order of appearance |
| interfaceList []*types.Interface // for delayed completion only |
| trackAllTypes bool |
| |
| // position encoding |
| posInfoFormat bool |
| prevFile string |
| prevLine int |
| fset *token.FileSet |
| files map[string]*token.File |
| |
| // debugging support |
| debugFormat bool |
| read int // bytes read |
| } |
| |
| // BImportData imports a package from the serialized package data |
| // and returns the number of bytes consumed and a reference to the package. |
| // If the export data version is not recognized or the format is otherwise |
| // compromised, an error is returned. |
| func BImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (_ int, pkg *types.Package, err error) { |
| // catch panics and return them as errors |
| defer func() { |
| if e := recover(); e != nil { |
| // The package (filename) causing the problem is added to this |
| // error by a wrapper in the caller (Import in gcimporter.go). |
| // Return a (possibly nil or incomplete) package unchanged (see #16088). |
| err = fmt.Errorf("cannot import, possibly version skew (%v) - reinstall package", e) |
| } |
| }() |
| |
| p := importer{ |
| imports: imports, |
| data: data, |
| importpath: path, |
| version: -1, // unknown version |
| strList: []string{""}, // empty string is mapped to 0 |
| pathList: []string{""}, // empty string is mapped to 0 |
| fset: fset, |
| files: make(map[string]*token.File), |
| } |
| |
| // read version info |
| var versionstr string |
| if b := p.rawByte(); b == 'c' || b == 'd' { |
| // Go1.7 encoding; first byte encodes low-level |
| // encoding format (compact vs debug). |
| // For backward-compatibility only (avoid problems with |
| // old installed packages). Newly compiled packages use |
| // the extensible format string. |
| // TODO(gri) Remove this support eventually; after Go1.8. |
| if b == 'd' { |
| p.debugFormat = true |
| } |
| p.trackAllTypes = p.rawByte() == 'a' |
| p.posInfoFormat = p.int() != 0 |
| versionstr = p.string() |
| if versionstr == "v1" { |
| p.version = 0 |
| } |
| } else { |
| // Go1.8 extensible encoding |
| // read version string and extract version number (ignore anything after the version number) |
| versionstr = p.rawStringln(b) |
| if s := strings.SplitN(versionstr, " ", 3); len(s) >= 2 && s[0] == "version" { |
| if v, err := strconv.Atoi(s[1]); err == nil && v > 0 { |
| p.version = v |
| } |
| } |
| } |
| |
| // read version specific flags - extend as necessary |
| switch p.version { |
| // case 6: |
| // ... |
| // fallthrough |
| case 5, 4, 3, 2, 1: |
| p.debugFormat = p.rawStringln(p.rawByte()) == "debug" |
| p.trackAllTypes = p.int() != 0 |
| p.posInfoFormat = p.int() != 0 |
| case 0: |
| // Go1.7 encoding format - nothing to do here |
| default: |
| errorf("unknown export format version %d (%q)", p.version, versionstr) |
| } |
| |
| // --- generic export data --- |
| |
| // populate typList with predeclared "known" types |
| p.typList = append(p.typList, predeclared...) |
| |
| // read package data |
| pkg = p.pkg() |
| |
| // read objects of phase 1 only (see cmd/compiler/internal/gc/bexport.go) |
| objcount := 0 |
| for { |
| tag := p.tagOrIndex() |
| if tag == endTag { |
| break |
| } |
| p.obj(tag) |
| objcount++ |
| } |
| |
| // self-verification |
| if count := p.int(); count != objcount { |
| errorf("got %d objects; want %d", objcount, count) |
| } |
| |
| // ignore compiler-specific import data |
| |
| // complete interfaces |
| // TODO(gri) re-investigate if we still need to do this in a delayed fashion |
| for _, typ := range p.interfaceList { |
| typ.Complete() |
| } |
| |
| // record all referenced packages as imports |
| list := append(([]*types.Package)(nil), p.pkgList[1:]...) |
| sort.Sort(byPath(list)) |
| pkg.SetImports(list) |
| |
| // package was imported completely and without errors |
| pkg.MarkComplete() |
| |
| return p.read, pkg, nil |
| } |
| |
| func errorf(format string, args ...interface{}) { |
| panic(fmt.Sprintf(format, args...)) |
| } |
| |
| func (p *importer) pkg() *types.Package { |
| // if the package was seen before, i is its index (>= 0) |
| i := p.tagOrIndex() |
| if i >= 0 { |
| return p.pkgList[i] |
| } |
| |
| // otherwise, i is the package tag (< 0) |
| if i != packageTag { |
| errorf("unexpected package tag %d version %d", i, p.version) |
| } |
| |
| // read package data |
| name := p.string() |
| var path string |
| if p.version >= 5 { |
| path = p.path() |
| } else { |
| path = p.string() |
| } |
| |
| // we should never see an empty package name |
| if name == "" { |
| errorf("empty package name in import") |
| } |
| |
| // an empty path denotes the package we are currently importing; |
| // it must be the first package we see |
| if (path == "") != (len(p.pkgList) == 0) { |
| errorf("package path %q for pkg index %d", path, len(p.pkgList)) |
| } |
| |
| // if the package was imported before, use that one; otherwise create a new one |
| if path == "" { |
| path = p.importpath |
| } |
| pkg := p.imports[path] |
| if pkg == nil { |
| pkg = types.NewPackage(path, name) |
| p.imports[path] = pkg |
| } else if pkg.Name() != name { |
| errorf("conflicting names %s and %s for package %q", pkg.Name(), name, path) |
| } |
| p.pkgList = append(p.pkgList, pkg) |
| |
| return pkg |
| } |
| |
| // objTag returns the tag value for each object kind. |
| func objTag(obj types.Object) int { |
| switch obj.(type) { |
| case *types.Const: |
| return constTag |
| case *types.TypeName: |
| return typeTag |
| case *types.Var: |
| return varTag |
| case *types.Func: |
| return funcTag |
| default: |
| errorf("unexpected object: %v (%T)", obj, obj) // panics |
| panic("unreachable") |
| } |
| } |
| |
| func sameObj(a, b types.Object) bool { |
| // Because unnamed types are not canonicalized, we cannot simply compare types for |
| // (pointer) identity. |
| // Ideally we'd check equality of constant values as well, but this is good enough. |
| return objTag(a) == objTag(b) && types.Identical(a.Type(), b.Type()) |
| } |
| |
| func (p *importer) declare(obj types.Object) { |
| pkg := obj.Pkg() |
| if alt := pkg.Scope().Insert(obj); alt != nil { |
| // This can only trigger if we import a (non-type) object a second time. |
| // Excluding type aliases, this cannot happen because 1) we only import a package |
| // once; and b) we ignore compiler-specific export data which may contain |
| // functions whose inlined function bodies refer to other functions that |
| // were already imported. |
| // However, type aliases require reexporting the original type, so we need |
| // to allow it (see also the comment in cmd/compile/internal/gc/bimport.go, |
| // method importer.obj, switch case importing functions). |
| // TODO(gri) review/update this comment once the gc compiler handles type aliases. |
| if !sameObj(obj, alt) { |
| errorf("inconsistent import:\n\t%v\npreviously imported as:\n\t%v\n", obj, alt) |
| } |
| } |
| } |
| |
| func (p *importer) obj(tag int) { |
| switch tag { |
| case constTag: |
| pos := p.pos() |
| pkg, name := p.qualifiedName() |
| typ := p.typ(nil) |
| val := p.value() |
| p.declare(types.NewConst(pos, pkg, name, typ, val)) |
| |
| case aliasTag: |
| // TODO(gri) verify type alias hookup is correct |
| pos := p.pos() |
| pkg, name := p.qualifiedName() |
| typ := p.typ(nil) |
| p.declare(types.NewTypeName(pos, pkg, name, typ)) |
| |
| case typeTag: |
| p.typ(nil) |
| |
| case varTag: |
| pos := p.pos() |
| pkg, name := p.qualifiedName() |
| typ := p.typ(nil) |
| p.declare(types.NewVar(pos, pkg, name, typ)) |
| |
| case funcTag: |
| pos := p.pos() |
| pkg, name := p.qualifiedName() |
| params, isddd := p.paramList() |
| result, _ := p.paramList() |
| sig := types.NewSignature(nil, params, result, isddd) |
| p.declare(types.NewFunc(pos, pkg, name, sig)) |
| |
| default: |
| errorf("unexpected object tag %d", tag) |
| } |
| } |
| |
| const deltaNewFile = -64 // see cmd/compile/internal/gc/bexport.go |
| |
| func (p *importer) pos() token.Pos { |
| if !p.posInfoFormat { |
| return token.NoPos |
| } |
| |
| file := p.prevFile |
| line := p.prevLine |
| delta := p.int() |
| line += delta |
| if p.version >= 5 { |
| if delta == deltaNewFile { |
| if n := p.int(); n >= 0 { |
| // file changed |
| file = p.path() |
| line = n |
| } |
| } |
| } else { |
| if delta == 0 { |
| if n := p.int(); n >= 0 { |
| // file changed |
| file = p.prevFile[:n] + p.string() |
| line = p.int() |
| } |
| } |
| } |
| p.prevFile = file |
| p.prevLine = line |
| |
| // Synthesize a token.Pos |
| |
| // Since we don't know the set of needed file positions, we |
| // reserve maxlines positions per file. |
| const maxlines = 64 * 1024 |
| f := p.files[file] |
| if f == nil { |
| f = p.fset.AddFile(file, -1, maxlines) |
| p.files[file] = f |
| // Allocate the fake linebreak indices on first use. |
| // TODO(adonovan): opt: save ~512KB using a more complex scheme? |
| fakeLinesOnce.Do(func() { |
| fakeLines = make([]int, maxlines) |
| for i := range fakeLines { |
| fakeLines[i] = i |
| } |
| }) |
| f.SetLines(fakeLines) |
| } |
| |
| if line > maxlines { |
| line = 1 |
| } |
| |
| // Treat the file as if it contained only newlines |
| // and column=1: use the line number as the offset. |
| return f.Pos(line - 1) |
| } |
| |
| var ( |
| fakeLines []int |
| fakeLinesOnce sync.Once |
| ) |
| |
| func (p *importer) qualifiedName() (pkg *types.Package, name string) { |
| name = p.string() |
| pkg = p.pkg() |
| return |
| } |
| |
| func (p *importer) record(t types.Type) { |
| p.typList = append(p.typList, t) |
| } |
| |
| // A dddSlice is a types.Type representing ...T parameters. |
| // It only appears for parameter types and does not escape |
| // the importer. |
| type dddSlice struct { |
| elem types.Type |
| } |
| |
| func (t *dddSlice) Underlying() types.Type { return t } |
| func (t *dddSlice) String() string { return "..." + t.elem.String() } |
| |
| // parent is the package which declared the type; parent == nil means |
| // the package currently imported. The parent package is needed for |
| // exported struct fields and interface methods which don't contain |
| // explicit package information in the export data. |
| func (p *importer) typ(parent *types.Package) types.Type { |
| // if the type was seen before, i is its index (>= 0) |
| i := p.tagOrIndex() |
| if i >= 0 { |
| return p.typList[i] |
| } |
| |
| // otherwise, i is the type tag (< 0) |
| switch i { |
| case namedTag: |
| // read type object |
| pos := p.pos() |
| parent, name := p.qualifiedName() |
| scope := parent.Scope() |
| obj := scope.Lookup(name) |
| |
| // if the object doesn't exist yet, create and insert it |
| if obj == nil { |
| obj = types.NewTypeName(pos, parent, name, nil) |
| scope.Insert(obj) |
| } |
| |
| if _, ok := obj.(*types.TypeName); !ok { |
| errorf("pkg = %s, name = %s => %s", parent, name, obj) |
| } |
| |
| // associate new named type with obj if it doesn't exist yet |
| t0 := types.NewNamed(obj.(*types.TypeName), nil, nil) |
| |
| // but record the existing type, if any |
| t := obj.Type().(*types.Named) |
| p.record(t) |
| |
| // read underlying type |
| t0.SetUnderlying(p.typ(parent)) |
| |
| // interfaces don't have associated methods |
| if types.IsInterface(t0) { |
| return t |
| } |
| |
| // read associated methods |
| for i := p.int(); i > 0; i-- { |
| // TODO(gri) replace this with something closer to fieldName |
| pos := p.pos() |
| name := p.string() |
| if !exported(name) { |
| p.pkg() |
| } |
| |
| recv, _ := p.paramList() // TODO(gri) do we need a full param list for the receiver? |
| params, isddd := p.paramList() |
| result, _ := p.paramList() |
| p.int() // go:nointerface pragma - discarded |
| |
| sig := types.NewSignature(recv.At(0), params, result, isddd) |
| t0.AddMethod(types.NewFunc(pos, parent, name, sig)) |
| } |
| |
| return t |
| |
| case arrayTag: |
| t := new(types.Array) |
| if p.trackAllTypes { |
| p.record(t) |
| } |
| |
| n := p.int64() |
| *t = *types.NewArray(p.typ(parent), n) |
| return t |
| |
| case sliceTag: |
| t := new(types.Slice) |
| if p.trackAllTypes { |
| p.record(t) |
| } |
| |
| *t = *types.NewSlice(p.typ(parent)) |
| return t |
| |
| case dddTag: |
| t := new(dddSlice) |
| if p.trackAllTypes { |
| p.record(t) |
| } |
| |
| t.elem = p.typ(parent) |
| return t |
| |
| case structTag: |
| t := new(types.Struct) |
| if p.trackAllTypes { |
| p.record(t) |
| } |
| |
| *t = *types.NewStruct(p.fieldList(parent)) |
| return t |
| |
| case pointerTag: |
| t := new(types.Pointer) |
| if p.trackAllTypes { |
| p.record(t) |
| } |
| |
| *t = *types.NewPointer(p.typ(parent)) |
| return t |
| |
| case signatureTag: |
| t := new(types.Signature) |
| if p.trackAllTypes { |
| p.record(t) |
| } |
| |
| params, isddd := p.paramList() |
| result, _ := p.paramList() |
| *t = *types.NewSignature(nil, params, result, isddd) |
| return t |
| |
| case interfaceTag: |
| // Create a dummy entry in the type list. This is safe because we |
| // cannot expect the interface type to appear in a cycle, as any |
| // such cycle must contain a named type which would have been |
| // first defined earlier. |
| n := len(p.typList) |
| if p.trackAllTypes { |
| p.record(nil) |
| } |
| |
| var embeddeds []*types.Named |
| for n := p.int(); n > 0; n-- { |
| p.pos() |
| embeddeds = append(embeddeds, p.typ(parent).(*types.Named)) |
| } |
| |
| t := types.NewInterface(p.methodList(parent), embeddeds) |
| p.interfaceList = append(p.interfaceList, t) |
| if p.trackAllTypes { |
| p.typList[n] = t |
| } |
| return t |
| |
| case mapTag: |
| t := new(types.Map) |
| if p.trackAllTypes { |
| p.record(t) |
| } |
| |
| key := p.typ(parent) |
| val := p.typ(parent) |
| *t = *types.NewMap(key, val) |
| return t |
| |
| case chanTag: |
| t := new(types.Chan) |
| if p.trackAllTypes { |
| p.record(t) |
| } |
| |
| var dir types.ChanDir |
| // tag values must match the constants in cmd/compile/internal/gc/go.go |
| switch d := p.int(); d { |
| case 1 /* Crecv */ : |
| dir = types.RecvOnly |
| case 2 /* Csend */ : |
| dir = types.SendOnly |
| case 3 /* Cboth */ : |
| dir = types.SendRecv |
| default: |
| errorf("unexpected channel dir %d", d) |
| } |
| val := p.typ(parent) |
| *t = *types.NewChan(dir, val) |
| return t |
| |
| default: |
| errorf("unexpected type tag %d", i) // panics |
| panic("unreachable") |
| } |
| } |
| |
| func (p *importer) fieldList(parent *types.Package) (fields []*types.Var, tags []string) { |
| if n := p.int(); n > 0 { |
| fields = make([]*types.Var, n) |
| tags = make([]string, n) |
| for i := range fields { |
| fields[i], tags[i] = p.field(parent) |
| } |
| } |
| return |
| } |
| |
| func (p *importer) field(parent *types.Package) (*types.Var, string) { |
| pos := p.pos() |
| pkg, name, alias := p.fieldName(parent) |
| typ := p.typ(parent) |
| tag := p.string() |
| |
| anonymous := false |
| if name == "" { |
| // anonymous field - typ must be T or *T and T must be a type name |
| switch typ := deref(typ).(type) { |
| case *types.Basic: // basic types are named types |
| pkg = nil // // objects defined in Universe scope have no package |
| name = typ.Name() |
| case *types.Named: |
| name = typ.Obj().Name() |
| default: |
| errorf("named base type expected") |
| } |
| anonymous = true |
| } else if alias { |
| // anonymous field: we have an explicit name because it's an alias |
| anonymous = true |
| } |
| |
| return types.NewField(pos, pkg, name, typ, anonymous), tag |
| } |
| |
| func (p *importer) methodList(parent *types.Package) (methods []*types.Func) { |
| if n := p.int(); n > 0 { |
| methods = make([]*types.Func, n) |
| for i := range methods { |
| methods[i] = p.method(parent) |
| } |
| } |
| return |
| } |
| |
| func (p *importer) method(parent *types.Package) *types.Func { |
| pos := p.pos() |
| pkg, name, _ := p.fieldName(parent) |
| params, isddd := p.paramList() |
| result, _ := p.paramList() |
| sig := types.NewSignature(nil, params, result, isddd) |
| return types.NewFunc(pos, pkg, name, sig) |
| } |
| |
| func (p *importer) fieldName(parent *types.Package) (pkg *types.Package, name string, alias bool) { |
| name = p.string() |
| pkg = parent |
| if pkg == nil { |
| // use the imported package instead |
| pkg = p.pkgList[0] |
| } |
| if p.version == 0 && name == "_" { |
| // version 0 didn't export a package for _ fields |
| return |
| } |
| switch name { |
| case "": |
| // 1) field name matches base type name and is exported: nothing to do |
| case "?": |
| // 2) field name matches base type name and is not exported: need package |
| name = "" |
| pkg = p.pkg() |
| case "@": |
| // 3) field name doesn't match type name (alias) |
| name = p.string() |
| alias = true |
| fallthrough |
| default: |
| if !exported(name) { |
| pkg = p.pkg() |
| } |
| } |
| return |
| } |
| |
| func (p *importer) paramList() (*types.Tuple, bool) { |
| n := p.int() |
| if n == 0 { |
| return nil, false |
| } |
| // negative length indicates unnamed parameters |
| named := true |
| if n < 0 { |
| n = -n |
| named = false |
| } |
| // n > 0 |
| params := make([]*types.Var, n) |
| isddd := false |
| for i := range params { |
| params[i], isddd = p.param(named) |
| } |
| return types.NewTuple(params...), isddd |
| } |
| |
| func (p *importer) param(named bool) (*types.Var, bool) { |
| t := p.typ(nil) |
| td, isddd := t.(*dddSlice) |
| if isddd { |
| t = types.NewSlice(td.elem) |
| } |
| |
| var pkg *types.Package |
| var name string |
| if named { |
| name = p.string() |
| if name == "" { |
| errorf("expected named parameter") |
| } |
| if name != "_" { |
| pkg = p.pkg() |
| } |
| if i := strings.Index(name, "·"); i > 0 { |
| name = name[:i] // cut off gc-specific parameter numbering |
| } |
| } |
| |
| // read and discard compiler-specific info |
| p.string() |
| |
| return types.NewVar(token.NoPos, pkg, name, t), isddd |
| } |
| |
| func exported(name string) bool { |
| ch, _ := utf8.DecodeRuneInString(name) |
| return unicode.IsUpper(ch) |
| } |
| |
| func (p *importer) value() constant.Value { |
| switch tag := p.tagOrIndex(); tag { |
| case falseTag: |
| return constant.MakeBool(false) |
| case trueTag: |
| return constant.MakeBool(true) |
| case int64Tag: |
| return constant.MakeInt64(p.int64()) |
| case floatTag: |
| return p.float() |
| case complexTag: |
| re := p.float() |
| im := p.float() |
| return constant.BinaryOp(re, token.ADD, constant.MakeImag(im)) |
| case stringTag: |
| return constant.MakeString(p.string()) |
| case unknownTag: |
| return constant.MakeUnknown() |
| default: |
| errorf("unexpected value tag %d", tag) // panics |
| panic("unreachable") |
| } |
| } |
| |
| func (p *importer) float() constant.Value { |
| sign := p.int() |
| if sign == 0 { |
| return constant.MakeInt64(0) |
| } |
| |
| exp := p.int() |
| mant := []byte(p.string()) // big endian |
| |
| // remove leading 0's if any |
| for len(mant) > 0 && mant[0] == 0 { |
| mant = mant[1:] |
| } |
| |
| // convert to little endian |
| // TODO(gri) go/constant should have a more direct conversion function |
| // (e.g., once it supports a big.Float based implementation) |
| for i, j := 0, len(mant)-1; i < j; i, j = i+1, j-1 { |
| mant[i], mant[j] = mant[j], mant[i] |
| } |
| |
| // adjust exponent (constant.MakeFromBytes creates an integer value, |
| // but mant represents the mantissa bits such that 0.5 <= mant < 1.0) |
| exp -= len(mant) << 3 |
| if len(mant) > 0 { |
| for msd := mant[len(mant)-1]; msd&0x80 == 0; msd <<= 1 { |
| exp++ |
| } |
| } |
| |
| x := constant.MakeFromBytes(mant) |
| switch { |
| case exp < 0: |
| d := constant.Shift(constant.MakeInt64(1), token.SHL, uint(-exp)) |
| x = constant.BinaryOp(x, token.QUO, d) |
| case exp > 0: |
| x = constant.Shift(x, token.SHL, uint(exp)) |
| } |
| |
| if sign < 0 { |
| x = constant.UnaryOp(token.SUB, x, 0) |
| } |
| return x |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // Low-level decoders |
| |
| func (p *importer) tagOrIndex() int { |
| if p.debugFormat { |
| p.marker('t') |
| } |
| |
| return int(p.rawInt64()) |
| } |
| |
| func (p *importer) int() int { |
| x := p.int64() |
| if int64(int(x)) != x { |
| errorf("exported integer too large") |
| } |
| return int(x) |
| } |
| |
| func (p *importer) int64() int64 { |
| if p.debugFormat { |
| p.marker('i') |
| } |
| |
| return p.rawInt64() |
| } |
| |
| func (p *importer) path() string { |
| if p.debugFormat { |
| p.marker('p') |
| } |
| // if the path was seen before, i is its index (>= 0) |
| // (the empty string is at index 0) |
| i := p.rawInt64() |
| if i >= 0 { |
| return p.pathList[i] |
| } |
| // otherwise, i is the negative path length (< 0) |
| a := make([]string, -i) |
| for n := range a { |
| a[n] = p.string() |
| } |
| s := strings.Join(a, "/") |
| p.pathList = append(p.pathList, s) |
| return s |
| } |
| |
| func (p *importer) string() string { |
| if p.debugFormat { |
| p.marker('s') |
| } |
| // if the string was seen before, i is its index (>= 0) |
| // (the empty string is at index 0) |
| i := p.rawInt64() |
| if i >= 0 { |
| return p.strList[i] |
| } |
| // otherwise, i is the negative string length (< 0) |
| if n := int(-i); n <= cap(p.buf) { |
| p.buf = p.buf[:n] |
| } else { |
| p.buf = make([]byte, n) |
| } |
| for i := range p.buf { |
| p.buf[i] = p.rawByte() |
| } |
| s := string(p.buf) |
| p.strList = append(p.strList, s) |
| return s |
| } |
| |
| func (p *importer) marker(want byte) { |
| if got := p.rawByte(); got != want { |
| errorf("incorrect marker: got %c; want %c (pos = %d)", got, want, p.read) |
| } |
| |
| pos := p.read |
| if n := int(p.rawInt64()); n != pos { |
| errorf("incorrect position: got %d; want %d", n, pos) |
| } |
| } |
| |
| // rawInt64 should only be used by low-level decoders. |
| func (p *importer) rawInt64() int64 { |
| i, err := binary.ReadVarint(p) |
| if err != nil { |
| errorf("read error: %v", err) |
| } |
| return i |
| } |
| |
| // rawStringln should only be used to read the initial version string. |
| func (p *importer) rawStringln(b byte) string { |
| p.buf = p.buf[:0] |
| for b != '\n' { |
| p.buf = append(p.buf, b) |
| b = p.rawByte() |
| } |
| return string(p.buf) |
| } |
| |
| // needed for binary.ReadVarint in rawInt64 |
| func (p *importer) ReadByte() (byte, error) { |
| return p.rawByte(), nil |
| } |
| |
| // byte is the bottleneck interface for reading p.data. |
| // It unescapes '|' 'S' to '$' and '|' '|' to '|'. |
| // rawByte should only be used by low-level decoders. |
| func (p *importer) rawByte() byte { |
| b := p.data[0] |
| r := 1 |
| if b == '|' { |
| b = p.data[1] |
| r = 2 |
| switch b { |
| case 'S': |
| b = '$' |
| case '|': |
| // nothing to do |
| default: |
| errorf("unexpected escape sequence in export data") |
| } |
| } |
| p.data = p.data[r:] |
| p.read += r |
| return b |
| |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // Export format |
| |
| // Tags. Must be < 0. |
| const ( |
| // Objects |
| packageTag = -(iota + 1) |
| constTag |
| typeTag |
| varTag |
| funcTag |
| endTag |
| |
| // Types |
| namedTag |
| arrayTag |
| sliceTag |
| dddTag |
| structTag |
| pointerTag |
| signatureTag |
| interfaceTag |
| mapTag |
| chanTag |
| |
| // Values |
| falseTag |
| trueTag |
| int64Tag |
| floatTag |
| fractionTag // not used by gc |
| complexTag |
| stringTag |
| nilTag // only used by gc (appears in exported inlined function bodies) |
| unknownTag // not used by gc (only appears in packages with errors) |
| |
| // Type aliases |
| aliasTag |
| ) |
| |
| var predeclared = []types.Type{ |
| // basic types |
| types.Typ[types.Bool], |
| types.Typ[types.Int], |
| types.Typ[types.Int8], |
| types.Typ[types.Int16], |
| types.Typ[types.Int32], |
| types.Typ[types.Int64], |
| types.Typ[types.Uint], |
| types.Typ[types.Uint8], |
| types.Typ[types.Uint16], |
| types.Typ[types.Uint32], |
| types.Typ[types.Uint64], |
| types.Typ[types.Uintptr], |
| types.Typ[types.Float32], |
| types.Typ[types.Float64], |
| types.Typ[types.Complex64], |
| types.Typ[types.Complex128], |
| types.Typ[types.String], |
| |
| // basic type aliases |
| types.Universe.Lookup("byte").Type(), |
| types.Universe.Lookup("rune").Type(), |
| |
| // error |
| types.Universe.Lookup("error").Type(), |
| |
| // untyped types |
| types.Typ[types.UntypedBool], |
| types.Typ[types.UntypedInt], |
| types.Typ[types.UntypedRune], |
| types.Typ[types.UntypedFloat], |
| types.Typ[types.UntypedComplex], |
| types.Typ[types.UntypedString], |
| types.Typ[types.UntypedNil], |
| |
| // package unsafe |
| types.Typ[types.UnsafePointer], |
| |
| // invalid type |
| types.Typ[types.Invalid], // only appears in packages with errors |
| |
| // used internally by gc; never used by this package or in .a files |
| anyType{}, |
| } |
| |
| type anyType struct{} |
| |
| func (t anyType) Underlying() types.Type { return t } |
| func (t anyType) String() string { return "any" } |