Subversion Repositories openrisc

// Copyright 2011 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 implements an ast.Importer for gc generated object files.
// TODO(gri) Eventually move this into a separate package outside types.

package types

import (
        "errors"
        "fmt"
        "go/ast"
        "go/token"
        "io"
        "math/big"
        "os"
        "path/filepath"
        "runtime"
        "strconv"
        "text/scanner"
)

const trace = false // set to true for debugging

var (
        pkgRoot = filepath.Join(runtime.GOROOT(), "pkg", runtime.GOOS+"_"+runtime.GOARCH)
        pkgExts = [...]string{".a", ".5", ".6", ".8"}
)

// findPkg returns the filename and package id for an import path.
// If no file was found, an empty filename is returned.
func findPkg(path string) (filename, id string) {
        if len(path) == 0 {
                return
        }

        id = path
        var noext string
        switch path[0] {
        default:
                // "x" -> "$GOROOT/pkg/$GOOS_$GOARCH/x.ext", "x"
                noext = filepath.Join(pkgRoot, path)

        case '.':
                // "./x" -> "/this/directory/x.ext", "/this/directory/x"
                cwd, err := os.Getwd()
                if err != nil {
                        return
                }
                noext = filepath.Join(cwd, path)
                id = noext

        case '/':
                // "/x" -> "/x.ext", "/x"
                noext = path
        }

        // try extensions
        for _, ext := range pkgExts {
                filename = noext + ext
                if f, err := os.Stat(filename); err == nil && !f.IsDir() {
                        return
                }
        }

        filename = "" // not found
        return
}

// gcParser parses the exports inside a gc compiler-produced
// object/archive file and populates its scope with the results.
type gcParser struct {
        scanner scanner.Scanner
        tok     rune                   // current token
        lit     string                 // literal string; only valid for Ident, Int, String tokens
        id      string                 // package id of imported package
        imports map[string]*ast.Object // package id -> package object
}

func (p *gcParser) init(filename, id string, src io.Reader, imports map[string]*ast.Object) {
        p.scanner.Init(src)
        p.scanner.Error = func(_ *scanner.Scanner, msg string) { p.error(msg) }
        p.scanner.Mode = scanner.ScanIdents | scanner.ScanInts | scanner.ScanChars | scanner.ScanStrings | scanner.ScanComments | scanner.SkipComments
        p.scanner.Whitespace = 1<<'\t' | 1<<' '
        p.scanner.Filename = filename // for good error messages
        p.next()
        p.id = id
        p.imports = imports
}

func (p *gcParser) next() {
        p.tok = p.scanner.Scan()
        switch p.tok {
        case scanner.Ident, scanner.Int, scanner.String:
                p.lit = p.scanner.TokenText()
        default:
                p.lit = ""
        }
        if trace {
                fmt.Printf("%s: %q -> %q\n", scanner.TokenString(p.tok), p.scanner.TokenText(), p.lit)
        }
}

// GcImporter implements the ast.Importer signature.
func GcImporter(imports map[string]*ast.Object, path string) (pkg *ast.Object, err error) {
        if path == "unsafe" {
                return Unsafe, nil
        }

        defer func() {
                if r := recover(); r != nil {
                        err = r.(importError) // will re-panic if r is not an importError
                        if trace {
                                panic(err) // force a stack trace
                        }
                }
        }()

        filename, id := findPkg(path)
        if filename == "" {
                err = errors.New("can't find import: " + id)
                return
        }

        if pkg = imports[id]; pkg != nil {
                return // package was imported before
        }

        buf, err := ExportData(filename)
        if err != nil {
                return
        }
        defer buf.Close()

        if trace {
                fmt.Printf("importing %s (%s)\n", id, filename)
        }

        var p gcParser
        p.init(filename, id, buf, imports)
        pkg = p.parseExport()
        return
}

// Declare inserts a named object of the given kind in scope.
func (p *gcParser) declare(scope *ast.Scope, kind ast.ObjKind, name string) *ast.Object {
        // the object may have been imported before - if it exists
        // already in the respective package scope, return that object
        if obj := scope.Lookup(name); obj != nil {
                assert(obj.Kind == kind)
                return obj
        }

        // otherwise create a new object and insert it into the package scope
        obj := ast.NewObj(kind, name)
        if scope.Insert(obj) != nil {
                p.errorf("already declared: %v %s", kind, obj.Name)
        }

        // a new type object is a named type and may be referred
        // to before the underlying type is known - set it up
        if kind == ast.Typ {
                obj.Type = &Name{Obj: obj}
        }

        return obj
}

// ----------------------------------------------------------------------------
// Error handling

// Internal errors are boxed as importErrors.
type importError struct {
        pos scanner.Position
        err error
}

func (e importError) Error() string {
        return fmt.Sprintf("import error %s (byte offset = %d): %s", e.pos, e.pos.Offset, e.err)
}

func (p *gcParser) error(err interface{}) {
        if s, ok := err.(string); ok {
                err = errors.New(s)
        }
        // panic with a runtime.Error if err is not an error
        panic(importError{p.scanner.Pos(), err.(error)})
}

func (p *gcParser) errorf(format string, args ...interface{}) {
        p.error(fmt.Sprintf(format, args...))
}

func (p *gcParser) expect(tok rune) string {
        lit := p.lit
        if p.tok != tok {
                panic(1)
                p.errorf("expected %s, got %s (%s)", scanner.TokenString(tok), scanner.TokenString(p.tok), lit)
        }
        p.next()
        return lit
}

func (p *gcParser) expectSpecial(tok string) {
        sep := 'x' // not white space
        i := 0
        for i < len(tok) && p.tok == rune(tok[i]) && sep > ' ' {
                sep = p.scanner.Peek() // if sep <= ' ', there is white space before the next token
                p.next()
                i++
        }
        if i < len(tok) {
                p.errorf("expected %q, got %q", tok, tok[0:i])
        }
}

func (p *gcParser) expectKeyword(keyword string) {
        lit := p.expect(scanner.Ident)
        if lit != keyword {
                p.errorf("expected keyword %s, got %q", keyword, lit)
        }
}

// ----------------------------------------------------------------------------
// Import declarations

// ImportPath = string_lit .
//
func (p *gcParser) parsePkgId() *ast.Object {
        id, err := strconv.Unquote(p.expect(scanner.String))
        if err != nil {
                p.error(err)
        }

        switch id {
        case "":
                // id == "" stands for the imported package id
                // (only known at time of package installation)
                id = p.id
        case "unsafe":
                // package unsafe is not in the imports map - handle explicitly
                return Unsafe
        }

        pkg := p.imports[id]
        if pkg == nil {
                scope = ast.NewScope(nil)
                pkg = ast.NewObj(ast.Pkg, "")
                pkg.Data = scope
                p.imports[id] = pkg
        }

        return pkg
}

// dotIdentifier = ( ident | '·' ) { ident | int | '·' } .
func (p *gcParser) parseDotIdent() string {
        ident := ""
        if p.tok != scanner.Int {
                sep := 'x' // not white space
                for (p.tok == scanner.Ident || p.tok == scanner.Int || p.tok == '·') && sep > ' ' {
                        ident += p.lit
                        sep = p.scanner.Peek() // if sep <= ' ', there is white space before the next token
                        p.next()
                }
        }
        if ident == "" {
                p.expect(scanner.Ident) // use expect() for error handling
        }
        return ident
}

// ExportedName = "@" ImportPath "." dotIdentifier .
//
func (p *gcParser) parseExportedName() (*ast.Object, string) {
        p.expect('@')
        pkg := p.parsePkgId()
        p.expect('.')
        name := p.parseDotIdent()
        return pkg, name
}

// ----------------------------------------------------------------------------
// Types

// BasicType = identifier .
//
func (p *gcParser) parseBasicType() Type {
        id := p.expect(scanner.Ident)
        obj := Universe.Lookup(id)
        if obj == nil || obj.Kind != ast.Typ {
                p.errorf("not a basic type: %s", id)
        }
        return obj.Type.(Type)
}

// ArrayType = "[" int_lit "]" Type .
//
func (p *gcParser) parseArrayType() Type {
        // "[" already consumed and lookahead known not to be "]"
        lit := p.expect(scanner.Int)
        p.expect(']')
        elt := p.parseType()
        n, err := strconv.ParseUint(lit, 10, 64)
        if err != nil {
                p.error(err)
        }
        return &Array{Len: n, Elt: elt}
}

// MapType = "map" "[" Type "]" Type .
//
func (p *gcParser) parseMapType() Type {
        p.expectKeyword("map")
        p.expect('[')
        key := p.parseType()
        p.expect(']')
        elt := p.parseType()
        return &Map{Key: key, Elt: elt}
}

// Name = identifier | "?" | ExportedName  .
//
func (p *gcParser) parseName() (name string) {
        switch p.tok {
        case scanner.Ident:
                name = p.lit
                p.next()
        case '?':
                // anonymous
                p.next()
        case '@':
                // exported name prefixed with package path
                _, name = p.parseExportedName()
        default:
                p.error("name expected")
        }
        return
}

// Field = Name Type [ string_lit ] .
//
func (p *gcParser) parseField() (fld *ast.Object, tag string) {
        name := p.parseName()
        ftyp := p.parseType()
        if name == "" {
                // anonymous field - ftyp must be T or *T and T must be a type name
                if _, ok := Deref(ftyp).(*Name); !ok {
                        p.errorf("anonymous field expected")
                }
        }
        if p.tok == scanner.String {
                tag = p.expect(scanner.String)
        }
        fld = ast.NewObj(ast.Var, name)
        fld.Type = ftyp
        return
}

// StructType = "struct" "{" [ FieldList ] "}" .
// FieldList  = Field { ";" Field } .
//
func (p *gcParser) parseStructType() Type {
        var fields []*ast.Object
        var tags []string

        parseField := func() {
                fld, tag := p.parseField()
                fields = append(fields, fld)
                tags = append(tags, tag)
        }

        p.expectKeyword("struct")
        p.expect('{')
        if p.tok != '}' {
                parseField()
                for p.tok == ';' {
                        p.next()
                        parseField()
                }
        }
        p.expect('}')

        return &Struct{Fields: fields, Tags: tags}
}

// Parameter = ( identifier | "?" ) [ "..." ] Type [ string_lit ] .
//
func (p *gcParser) parseParameter() (par *ast.Object, isVariadic bool) {
        name := p.parseName()
        if name == "" {
                name = "_" // cannot access unnamed identifiers
        }
        if p.tok == '.' {
                p.expectSpecial("...")
                isVariadic = true
        }
        ptyp := p.parseType()
        // ignore argument tag
        if p.tok == scanner.String {
                p.expect(scanner.String)
        }
        par = ast.NewObj(ast.Var, name)
        par.Type = ptyp
        return
}

// Parameters    = "(" [ ParameterList ] ")" .
// ParameterList = { Parameter "," } Parameter .
//
func (p *gcParser) parseParameters() (list []*ast.Object, isVariadic bool) {
        parseParameter := func() {
                par, variadic := p.parseParameter()
                list = append(list, par)
                if variadic {
                        if isVariadic {
                                p.error("... not on final argument")
                        }
                        isVariadic = true
                }
        }

        p.expect('(')
        if p.tok != ')' {
                parseParameter()
                for p.tok == ',' {
                        p.next()
                        parseParameter()
                }
        }
        p.expect(')')

        return
}

// Signature = Parameters [ Result ] .
// Result    = Type | Parameters .
//
func (p *gcParser) parseSignature() *Func {
        params, isVariadic := p.parseParameters()

        // optional result type
        var results []*ast.Object
        switch p.tok {
        case scanner.Ident, '[', '*', '<', '@':
                // single, unnamed result
                result := ast.NewObj(ast.Var, "_")
                result.Type = p.parseType()
                results = []*ast.Object{result}
        case '(':
                // named or multiple result(s)
                var variadic bool
                results, variadic = p.parseParameters()
                if variadic {
                        p.error("... not permitted on result type")
                }
        }

        return &Func{Params: params, Results: results, IsVariadic: isVariadic}
}

// MethodOrEmbedSpec = Name [ Signature ] .
//
func (p *gcParser) parseMethodOrEmbedSpec() *ast.Object {
        p.parseName()
        if p.tok == '(' {
                p.parseSignature()
                // TODO(gri) compute method object
                return ast.NewObj(ast.Fun, "_")
        }
        // TODO lookup name and return that type
        return ast.NewObj(ast.Typ, "_")
}

// InterfaceType = "interface" "{" [ MethodOrEmbedList ] "}" .
// MethodOrEmbedList = MethodOrEmbedSpec { ";" MethodOrEmbedSpec } .
//
func (p *gcParser) parseInterfaceType() Type {
        var methods ObjList

        parseMethod := func() {
                switch m := p.parseMethodOrEmbedSpec(); m.Kind {
                case ast.Typ:
                        // TODO expand embedded methods
                case ast.Fun:
                        methods = append(methods, m)
                }
        }

        p.expectKeyword("interface")
        p.expect('{')
        if p.tok != '}' {
                parseMethod()
                for p.tok == ';' {
                        p.next()
                        parseMethod()
                }
        }
        p.expect('}')

        methods.Sort()
        return &Interface{Methods: methods}
}

// ChanType = ( "chan" [ "<-" ] | "<-" "chan" ) Type .
//
func (p *gcParser) parseChanType() Type {
        dir := ast.SEND | ast.RECV
        if p.tok == scanner.Ident {
                p.expectKeyword("chan")
                if p.tok == '<' {
                        p.expectSpecial("<-")
                        dir = ast.SEND
                }
        } else {
                p.expectSpecial("<-")
                p.expectKeyword("chan")
                dir = ast.RECV
        }
        elt := p.parseType()
        return &Chan{Dir: dir, Elt: elt}
}

// Type =
//      BasicType | TypeName | ArrayType | SliceType | StructType |
//      PointerType | FuncType | InterfaceType | MapType | ChanType |
//      "(" Type ")" .
// BasicType = ident .
// TypeName = ExportedName .
// SliceType = "[" "]" Type .
// PointerType = "*" Type .
// FuncType = "func" Signature .
//
func (p *gcParser) parseType() Type {
        switch p.tok {
        case scanner.Ident:
                switch p.lit {
                default:
                        return p.parseBasicType()
                case "struct":
                        return p.parseStructType()
                case "func":
                        // FuncType
                        p.next()
                        return p.parseSignature()
                case "interface":
                        return p.parseInterfaceType()
                case "map":
                        return p.parseMapType()
                case "chan":
                        return p.parseChanType()
                }
        case '@':
                // TypeName
                pkg, name := p.parseExportedName()
                return p.declare(pkg.Data.(*ast.Scope), ast.Typ, name).Type.(Type)
        case '[':
                p.next() // look ahead
                if p.tok == ']' {
                        // SliceType
                        p.next()
                        return &Slice{Elt: p.parseType()}
                }
                return p.parseArrayType()
        case '*':
                // PointerType
                p.next()
                return &Pointer{Base: p.parseType()}
        case '<':
                return p.parseChanType()
        case '(':
                // "(" Type ")"
                p.next()
                typ := p.parseType()
                p.expect(')')
                return typ
        }
        p.errorf("expected type, got %s (%q)", scanner.TokenString(p.tok), p.lit)
        return nil
}

// ----------------------------------------------------------------------------
// Declarations

// ImportDecl = "import" identifier string_lit .
//
func (p *gcParser) parseImportDecl() {
        p.expectKeyword("import")
        // The identifier has no semantic meaning in the import data.
        // It exists so that error messages can print the real package
        // name: binary.ByteOrder instead of "encoding/binary".ByteOrder.
        name := p.expect(scanner.Ident)
        pkg := p.parsePkgId()
        assert(pkg.Name == "" || pkg.Name == name)
        pkg.Name = name
}

// int_lit = [ "+" | "-" ] { "0" ... "9" } .
//
func (p *gcParser) parseInt() (sign, val string) {
        switch p.tok {
        case '-':
                p.next()
                sign = "-"
        case '+':
                p.next()
        }
        val = p.expect(scanner.Int)
        return
}

// number = int_lit [ "p" int_lit ] .
//
func (p *gcParser) parseNumber() Const {
        // mantissa
        sign, val := p.parseInt()
        mant, ok := new(big.Int).SetString(sign+val, 10)
        assert(ok)

        if p.lit == "p" {
                // exponent (base 2)
                p.next()
                sign, val = p.parseInt()
                exp64, err := strconv.ParseUint(val, 10, 0)
                if err != nil {
                        p.error(err)
                }
                exp := uint(exp64)
                if sign == "-" {
                        denom := big.NewInt(1)
                        denom.Lsh(denom, exp)
                        return Const{new(big.Rat).SetFrac(mant, denom)}
                }
                if exp > 0 {
                        mant.Lsh(mant, exp)
                }
                return Const{new(big.Rat).SetInt(mant)}
        }

        return Const{mant}
}

// ConstDecl   = "const" ExportedName [ Type ] "=" Literal .
// Literal     = bool_lit | int_lit | float_lit | complex_lit | string_lit .
// bool_lit    = "true" | "false" .
// complex_lit = "(" float_lit "+" float_lit ")" .
// rune_lit = "(" int_lit "+" int_lit ")" .
// string_lit  = `"` { unicode_char } `"` .
//
func (p *gcParser) parseConstDecl() {
        p.expectKeyword("const")
        pkg, name := p.parseExportedName()
        obj := p.declare(pkg.Data.(*ast.Scope), ast.Con, name)
        var x Const
        var typ Type
        if p.tok != '=' {
                obj.Type = p.parseType()
        }
        p.expect('=')
        switch p.tok {
        case scanner.Ident:
                // bool_lit
                if p.lit != "true" && p.lit != "false" {
                        p.error("expected true or false")
                }
                x = Const{p.lit == "true"}
                typ = Bool.Underlying
                p.next()
        case '-', scanner.Int:
                // int_lit
                x = p.parseNumber()
                typ = Int.Underlying
                if _, ok := x.val.(*big.Rat); ok {
                        typ = Float64.Underlying
                }
        case '(':
                // complex_lit or rune_lit
                p.next()
                if p.tok == scanner.Char {
                        p.next()
                        p.expect('+')
                        p.parseNumber()
                        p.expect(')')
                        // TODO: x = ...
                        break
                }
                re := p.parseNumber()
                p.expect('+')
                im := p.parseNumber()
                p.expect(')')
                x = Const{cmplx{re.val.(*big.Rat), im.val.(*big.Rat)}}
                typ = Complex128.Underlying
        case scanner.Char:
                // TODO: x = ...
                p.next()
        case scanner.String:
                // string_lit
                x = MakeConst(token.STRING, p.lit)
                p.next()
                typ = String.Underlying
        default:
                println(p.tok)
                p.errorf("expected literal got %s", scanner.TokenString(p.tok))
        }
        if obj.Type == nil {
                obj.Type = typ
        }
        obj.Data = x
}

// TypeDecl = "type" ExportedName Type .
//
func (p *gcParser) parseTypeDecl() {
        p.expectKeyword("type")
        pkg, name := p.parseExportedName()
        obj := p.declare(pkg.Data.(*ast.Scope), ast.Typ, name)

        // The type object may have been imported before and thus already
        // have a type associated with it. We still need to parse the type
        // structure, but throw it away if the object already has a type.
        // This ensures that all imports refer to the same type object for
        // a given type declaration.
        typ := p.parseType()

        if name := obj.Type.(*Name); name.Underlying == nil {
                assert(Underlying(typ) == typ)
                name.Underlying = typ
        }
}

// VarDecl = "var" ExportedName Type .
//
func (p *gcParser) parseVarDecl() {
        p.expectKeyword("var")
        pkg, name := p.parseExportedName()
        obj := p.declare(pkg.Data.(*ast.Scope), ast.Var, name)
        obj.Type = p.parseType()
}

// FuncBody = "{" ... "}" .
// 
func (p *gcParser) parseFuncBody() {
        p.expect('{')
        for i := 1; i > 0; p.next() {
                switch p.tok {
                case '{':
                        i++
                case '}':
                        i--
                }
        }
}

// FuncDecl = "func" ExportedName Signature [ FuncBody ] .
//
func (p *gcParser) parseFuncDecl() {
        // "func" already consumed
        pkg, name := p.parseExportedName()
        obj := p.declare(pkg.Data.(*ast.Scope), ast.Fun, name)
        obj.Type = p.parseSignature()
        if p.tok == '{' {
                p.parseFuncBody()
        }
}

// MethodDecl = "func" Receiver Name Signature .
// Receiver   = "(" ( identifier | "?" ) [ "*" ] ExportedName ")" [ FuncBody ].
//
func (p *gcParser) parseMethodDecl() {
        // "func" already consumed
        p.expect('(')
        p.parseParameter() // receiver
        p.expect(')')
        p.parseName() // unexported method names in imports are qualified with their package.
        p.parseSignature()
        if p.tok == '{' {
                p.parseFuncBody()
        }
}

// Decl = [ ImportDecl | ConstDecl | TypeDecl | VarDecl | FuncDecl | MethodDecl ] "\n" .
//
func (p *gcParser) parseDecl() {
        switch p.lit {
        case "import":
                p.parseImportDecl()
        case "const":
                p.parseConstDecl()
        case "type":
                p.parseTypeDecl()
        case "var":
                p.parseVarDecl()
        case "func":
                p.next() // look ahead
                if p.tok == '(' {
                        p.parseMethodDecl()
                } else {
                        p.parseFuncDecl()
                }
        }
        p.expect('\n')
}

// ----------------------------------------------------------------------------
// Export

// Export        = "PackageClause { Decl } "$$" .
// PackageClause = "package" identifier [ "safe" ] "\n" .
//
func (p *gcParser) parseExport() *ast.Object {
        p.expectKeyword("package")
        name := p.expect(scanner.Ident)
        if p.tok != '\n' {
                // A package is safe if it was compiled with the -u flag,
                // which disables the unsafe package.
                // TODO(gri) remember "safe" package
                p.expectKeyword("safe")
        }
        p.expect('\n')

        assert(p.imports[p.id] == nil)
        pkg := ast.NewObj(ast.Pkg, name)
        pkg.Data = ast.NewScope(nil)
        p.imports[p.id] = pkg

        for p.tok != '$' && p.tok != scanner.EOF {
                p.parseDecl()
        }

        if ch := p.scanner.Peek(); p.tok != '$' || ch != '$' {
                // don't call next()/expect() since reading past the
                // export data may cause scanner errors (e.g. NUL chars)
                p.errorf("expected '$$', got %s %c", scanner.TokenString(p.tok), ch)
        }

        if n := p.scanner.ErrorCount; n != 0 {
                p.errorf("expected no scanner errors, got %d", n)
        }

        return pkg
}