// This function is an adjusted variant of gccgoimporter.GccgoInstallation.GetImporter. func getNewImporter(searchpaths []string) types.Importer { return func(imports map[string]*types.Package, pkgpath string) (pkg *types.Package, err error) { if pkgpath == "unsafe" { return types.Unsafe, nil } fpath, err := findExportFile(searchpaths, pkgpath) if err != nil { return } reader, closer, err := openExportFile(fpath) if err != nil { return nil, err } defer closer.Close() // TODO(gri) At the moment we just read the entire file. // We should change importer.ImportData to take an io.Reader instead. data, err := ioutil.ReadAll(reader) if err != nil && err != io.EOF { return nil, err } return importer.ImportData(packages, data) } }
func (imp *Importer) importPkg(imports map[string]*types.Package, path string) (*types.Package, error) { if path == "unsafe" { return types.Unsafe, nil } var ( srcDir string err error ) if build.IsLocalImport(path) { srcDir, err = os.Getwd() if err != nil { return nil, err } } bp, err := buildCtx.Import(path, srcDir, build.AllowBinary) if err != nil { return nil, err } if pkg := imports[path]; pkg != nil && pkg.Complete() { return pkg, nil } buf, err := loadExports(bp) if err != nil { return nil, err } _, pkg, err := importer.ImportData(imports, buf) return pkg, err }
func (imp *Importer) Import(imports map[string]*types.Package, path string) (pkg *types.Package, err error) { exportsPath := packageExportsFile(imp.context, path) data, err := ioutil.ReadFile(exportsPath) if err != nil { // Package has not been compiled yet, so // fall back to the standard GcImport. tracef("Falling back to gc import data for: %s", path) return gcimporter.Import(imports, path) } tracef("Loading import data for %q from %q", path, exportsPath) return importer.ImportData(imports, data) }
func gccgoNewImporter(packages map[string]*types.Package, path string) (*types.Package, error) { reader, closer, err := openGccgoExportFile(path) if err != nil { return nil, err } defer closer.Close() // TODO(gri) importer.ImportData takes a []byte instead of an io.Reader; // hence the need to read some amount of data. At the same time we don't // want to read the entire, potentially very large object file. For now, // read 10K. Fix this! var data = make([]byte, 10<<10) n, err := reader.Read(data) if err != nil && err != io.EOF { return nil, err } return importer.ImportData(packages, data[:n]) }
func GetImporter(searchpaths []string, initmap map[*types.Package]InitData) types.Importer { return func(imports map[string]*types.Package, pkgpath string) (pkg *types.Package, err error) { if pkgpath == "unsafe" { return types.Unsafe, nil } fpath, err := findExportFile(searchpaths, pkgpath) if err != nil { return } reader, closer, err := openExportFile(fpath) if err != nil { return } if closer != nil { defer closer.Close() } var magic [4]byte _, err = reader.Read(magic[:]) if err != nil { return } _, err = reader.Seek(0, 0) if err != nil { return } switch string(magic[:]) { case gccgov1Magic: var p parser p.init(fpath, reader, imports) pkg = p.parsePackage() if initmap != nil { initmap[pkg] = p.initdata } case goimporterMagic: var data []byte data, err = ioutil.ReadAll(reader) if err != nil { return } var n int n, pkg, err = importer.ImportData(imports, data) if err != nil { return } if initmap != nil { suffixreader := bytes.NewReader(data[n:]) var p parser p.init(fpath, suffixreader, nil) p.parseInitData() initmap[pkg] = p.initdata } default: err = fmt.Errorf("unrecognized magic string: %q", string(magic[:])) } return } }