"bytes"
"debug/elf"
"errors"
"fmt"
"internal/xcoff"
"io"
"strconv"
"strings"
"bufio"
"go/types"
"os"
"os/exec"
"path/filepath"
"strings"
"bytes"
"debug/elf"
"fmt"
"go/types"
"internal/xcoff"
"io"
"os"
"path/filepath"
"strings"
"errors"
"fmt"
"go/constant"
"go/token"
"go/types"
"io"
"strconv"
"strings"
"text/scanner"
"unicode/utf8"
const aixbigafMagic = "Offsets and sizes for fields in a standard archive header.
const arDateOff = *ast.BinaryExprOffsets and sizes for fields in a standard archive header.
const arDateSize = 12Offsets and sizes for fields in a standard archive header.
const arFmagOff = *ast.BinaryExprOffsets and sizes for fields in a standard archive header.
const arFmagSize = 2Offsets and sizes for fields in a standard archive header.
const arGIDOff = *ast.BinaryExprOffsets and sizes for fields in a standard archive header.
const arGIDSize = 6Offsets and sizes for fields in a standard archive header.
const arHdrSize = *ast.BinaryExprOffsets and sizes for fields in a standard archive header.
const arModeOff = *ast.BinaryExprOffsets and sizes for fields in a standard archive header.
const arModeSize = 8Offsets and sizes for fields in a standard archive header.
const arNameOff = 0Offsets and sizes for fields in a standard archive header.
const arNameSize = 16Offsets and sizes for fields in a standard archive header.
const arSizeOff = *ast.BinaryExprOffsets and sizes for fields in a standard archive header.
const arSizeSize = 10Offsets and sizes for fields in a standard archive header.
const arUIDOff = *ast.BinaryExprOffsets and sizes for fields in a standard archive header.
const arUIDSize = 6const archiveMagic = "!The contents of the fmag field of a standard archive header.
const arfmag = "`\n"Magic strings for different archive file formats.
const armag = "!\n" Magic strings for different archive file formats.
const armagb = "\n" Magic strings for different archive file formats.
const armagt = "!\n" const gccgoBuiltinANY = 22const gccgoBuiltinBOOL = 15const gccgoBuiltinBYTE = 20const gccgoBuiltinCOMPLEX128 = 18const gccgoBuiltinCOMPLEX64 = 17const gccgoBuiltinERROR = 19const gccgoBuiltinFLOAT32 = 9const gccgoBuiltinFLOAT64 = 10const gccgoBuiltinINT = 11const gccgoBuiltinINT16 = 2const gccgoBuiltinINT32 = 3const gccgoBuiltinINT64 = 4From gofrontend/go/export.h Note that these values are negative in the gofrontend and have been made positive in the gccgoimporter.
const gccgoBuiltinINT8 = 1const gccgoBuiltinRUNE = 21const gccgoBuiltinSTRING = 16const gccgoBuiltinUINT = 12const gccgoBuiltinUINT16 = 6const gccgoBuiltinUINT32 = 7const gccgoBuiltinUINT64 = 8const gccgoBuiltinUINT8 = 5const gccgoBuiltinUINTPTR = 13const gccgov1Magic = "v1;\n"const gccgov2Magic = "v2;\n"const gccgov3Magic = "v3;\n"const goimporterMagic = "\n$$ "reserved is a singleton type used to fill type map slots that have been reserved (i.e., for which a type number has been parsed) but which don't have their actual type yet. When the type map is updated, the actual type must replace a reserved entry (or we have an internal error). Used for self-verification only - not required for correctness.
var reserved = *ast.CallExprAn Importer resolves import paths to Packages. The imports map records packages already known, indexed by package path. An importer must determine the canonical package path and check imports to see if it is already present in the map. If so, the Importer can return the map entry. Otherwise, the importer must load the package data for the given path into a new *Package, record it in imports map, and return the package.
type Importer func(imports map[string]*types.Package, path string, srcDir string, lookup func(string) (io.ReadCloser, error)) (*types.Package, error)Information about a specific installation of gccgo.
type GccgoInstallation struct {
GccVersion string
TargetTriple string
LibPaths []string
}The gccgo-specific init data for a package.
type InitData struct {
Priority int
Inits []PackageInit
}A PackageInit describes an imported package that needs initialization.
type PackageInit struct {
Name string
InitFunc string
Priority int
}type fixupRecord struct {
toUpdate *types.Named
target types.Type
}type importError struct {
pos scanner.Position
err error
}type parser struct {
scanner *scanner.Scanner
version string
tok rune
lit string
pkgpath string
pkgname string
pkg *types.Package
imports map[string]*types.Package
typeList []types.Type
typeData []string
fixups []fixupRecord
initdata InitData
aliases map[int]string
}type seekerReadAt struct {
seeker io.ReadSeeker
}func (e importError) Error() stringfunc GetImporter(searchpaths []string, initmap map[*types.Package]InitData) ImporterReturn an importer that searches incpaths followed by the gcc installation's built-in search paths and the current directory.
func (inst *GccgoInstallation) GetImporter(incpaths []string, initmap map[*types.Package]InitData) ImporterAsk the driver at the given path for information for this GccgoInstallation. The given arguments are passed directly to the call of the driver.
func (inst *GccgoInstallation) InitFromDriver(gccgoPath string, args ...string) (err error)func (sra seekerReadAt) ReadAt(p []byte, off int64) (int, error)Return the list of export search paths for this GccgoInstallation.
func (inst *GccgoInstallation) SearchPaths() (paths []string)aixBigArExportData returns export data from an AIX big archive.
func aixBigArExportData(archive io.ReadSeeker) (io.ReadSeeker, error)arExportData takes an archive file and returns a ReadSeeker for the export data in that file. This assumes that there is only one object in the archive containing export data, which is not quite what gccgo does; gccgo concatenates together all the export data for all the objects in the file. In practice that case does not arise.
func arExportData(archive io.ReadSeeker) (io.ReadSeeker, error)func deref(typ types.Type) types.TypeelfFromAr tries to get export data from an archive member as an ELF file. If there is no export data, this returns nil, nil.
func elfFromAr(member *io.SectionReader) (io.ReadSeeker, error)func (p *parser) error(err any)func (p *parser) errorf(format string, args ...any)func (p *parser) expect(tok rune) stringfunc (p *parser) expectEOL()func (p *parser) expectKeyword(keyword string)Locate the file from which to read export data. This is intended to replicate the logic in gofrontend.
func findExportFile(searchpaths []string, pkgpath string) (string, error)getPkg returns the package for a given path. If the package is not found but we have a package name, create the package and add it to the p.imports map.
func (p *parser) getPkg(pkgpath string, name string) *types.Packagefunc (p *parser) init(filename string, src io.Reader, imports map[string]*types.Package)func (p *parser) initScanner(filename string, src io.Reader)func lookupBuiltinType(typ int) types.TypeCreate the package if we have parsed both the package path and package name.
func (p *parser) maybeCreatePackage()func (p *parser) next()Opens the export data file at the given path. If this is an ELF file, searches for and opens the .go_export section. If this is an archive, reads the export data from the first member, which is assumed to be an ELF file. This is intended to replicate the logic in gofrontend.
func openExportFile(fpath string) (reader io.ReadSeeker, closer io.Closer, err error)ArrayOrSliceType = "[" [ int ] "]" Type .
func (p *parser) parseArrayOrSliceType(pkg *types.Package, nlist []any) types.TypeChanType = "chan" ["<-" | "-<"] Type .
func (p *parser) parseChanType(pkg *types.Package, nlist []any) types.TypeConst = Name [Type] "=" ConstValue .
func (p *parser) parseConst(pkg *types.Package) *types.ConstConstValue = string | "false" | "true" | ["-"] (int ["'"] | FloatOrComplex) | Conversion . FloatOrComplex = float ["i" | ("+"|"-") float "i"] .
func (p *parser) parseConstValue(pkg *types.Package) (val constant.Value, typ types.Type)Conversion = "convert" "(" Type "," ConstValue ")" .
func (p *parser) parseConversion(pkg *types.Package) (val constant.Value, typ types.Type)Directive = InitDataDirective | "package" unquotedString [ unquotedString ] [ unquotedString ] ";" | "pkgpath" unquotedString ";" | "prefix" unquotedString ";" | "import" unquotedString unquotedString string ";" | "indirectimport" unquotedString unquotedstring ";" | "func" Func ";" | "type" Type ";" | "var" Var ";" | "const" Const ";" .
func (p *parser) parseDirective()parseExportedName is like parseQualifiedName, but the package path is resolved to an imported *types.Package. ExportedName = string [string] .
func (p *parser) parseExportedName() (pkg *types.Package, name string)Field = Name Type [string] .
func (p *parser) parseField(pkg *types.Package) (field *types.Var, tag string)Func = Name FunctionType [InlineBody] .
func (p *parser) parseFunc(pkg *types.Package) *types.FuncFunctionType = ParamList ResultList .
func (p *parser) parseFunctionType(pkg *types.Package, nlist []any) *types.SignatureInitDataDirective = ( "v1" | "v2" | "v3" ) ";" | "priority" int ";" | "init" { PackageInit } ";" | "checksum" unquotedString ";" .
func (p *parser) parseInitDataDirective()func (p *parser) parseInt() intfunc (p *parser) parseInt64() int64InterfaceType = "interface" "{" { ("?" Type | Func) ";" } "}" .
func (p *parser) parseInterfaceType(pkg *types.Package, nlist []any) types.TypeMapType = "map" "[" Type "]" Type .
func (p *parser) parseMapType(pkg *types.Package, nlist []any) types.TypeName = QualifiedName | "?" .
func (p *parser) parseName() stringNamedType = TypeName [ "=" ] Type { Method } . TypeName = ExportedName . Method = "func" "(" Param ")" Name ParamList ResultList [InlineBody] ";" .
func (p *parser) parseNamedType(nlist []any) types.TypePackage = { Directive } .
func (p *parser) parsePackage() *types.PackagePackageInit = unquotedString unquotedString int .
func (p *parser) parsePackageInit() PackageInitParam = Name ["..."] Type .
func (p *parser) parseParam(pkg *types.Package) (param *types.Var, isVariadic bool)ParamList = "(" [ { Parameter "," } Parameter ] ")" .
func (p *parser) parseParamList(pkg *types.Package) (*types.Tuple, bool)PointerType = "*" ("any" | Type) .
func (p *parser) parsePointerType(pkg *types.Package, nlist []any) types.Typefunc (p *parser) parseQualifiedName() (path string, name string)qualifiedName = [ ["."] unquotedString "." ] unquotedString . The above production uses greedy matching.
func (p *parser) parseQualifiedNameStr(unquotedName string) (pkgpath string, name string)ResultList = Type | ParamList .
func (p *parser) parseResultList(pkg *types.Package) *types.TupleparseSavedType parses one saved type definition.
func (p *parser) parseSavedType(pkg *types.Package, i int, nlist []any)func (p *parser) parseString() stringStructType = "struct" "{" { Field } "}" .
func (p *parser) parseStructType(pkg *types.Package, nlist []any) types.TypeType = "<" "type" ( "-" int | int [ TypeSpec ] ) ">" . parseType updates the type map to t for all type numbers n.
func (p *parser) parseType(pkg *types.Package, n ...any) types.Type(*parser).Type after reading the "<".
func (p *parser) parseTypeAfterAngle(pkg *types.Package, n ...any) (t types.Type, n1 int)parseTypeExtended is identical to parseType, but if the type in question is a saved type, returns the index as well as the type pointer (index returned is zero if we parsed a builtin).
func (p *parser) parseTypeExtended(pkg *types.Package, n ...any) (t types.Type, n1 int)TypeSpec = NamedType | MapType | ChanType | StructType | InterfaceType | PointerType | ArrayOrSliceType | FunctionType .
func (p *parser) parseTypeSpec(pkg *types.Package, nlist []any) types.TypeTypes = "types" maxp1 exportedp1 (offset length)* .
func (p *parser) parseTypes(pkg *types.Package)func (p *parser) parseUnquotedQualifiedName() (path string, name string)unquotedString = { unquotedStringChar } .
unquotedStringChar =
func (p *parser) parseUnquotedString() stringVar = Name Type .
func (p *parser) parseVar(pkg *types.Package) *types.VarreadMagic reads the four bytes at the start of a ReadSeeker and returns them as a string.
func readMagic(reader io.ReadSeeker) (string, error)readerAtFromSeeker turns an io.ReadSeeker into an io.ReaderAt. This is only safe because there won't be any concurrent seeks while this code is executing.
func readerAtFromSeeker(rs io.ReadSeeker) io.ReaderAtreserve reserves the type map entry n for future use.
func (p *parser) reserve(n int)InlineBody = "
func (p *parser) skipInlineBody()standardArExportData returns export data from a standard archive.
func standardArExportData(archive io.ReadSeeker) (io.ReadSeeker, error)update sets the type map entries for the entries in nlist to t. An entry in nlist can be a type number in p.typeList, used to resolve named types, or it can be a *types.Pointer, used to resolve pointers to named types in case they are referenced by embedded fields.
func (p *parser) update(t types.Type, nlist []any)Generated with Arrow