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.

package main

import (

        "errors"

        "exp/types"

        "flag"

        "fmt"

        "go/ast"

        "go/parser"

        "go/scanner"

        "go/token"

        "io/ioutil"

        "os"

        "path/filepath"

        "strings"

)

var (

        // main operation modes

        pkgName   = flag.String("p", "", "process only those files in package pkgName")

        recursive = flag.Bool("r", false, "recursively process subdirectories")

        verbose   = flag.Bool("v", false, "verbose mode")

        allErrors = flag.Bool("e", false, "print all (including spurious) errors")

        // debugging support

        printTrace = flag.Bool("trace", false, "print parse trace")

        printAST   = flag.Bool("ast", false, "print AST")

)

var exitCode = 0

func usage() {

        fmt.Fprintf(os.Stderr, "usage: gotype [flags] [path ...]\n")

        flag.PrintDefaults()

        os.Exit(2)

}

func report(err error) {

        scanner.PrintError(os.Stderr, err)

        exitCode = 2

}

// parse returns the AST for the Go source src.

// The filename is for error reporting only.

// The result is nil if there were errors or if

// the file does not belong to the -p package.

func parse(fset *token.FileSet, filename string, src []byte) *ast.File {

        if *verbose {

                fmt.Println(filename)

        }

        // ignore files with different package name

        if *pkgName != "" {

                file, err := parser.ParseFile(fset, filename, src, parser.PackageClauseOnly)

                if err != nil {

                        report(err)

                        return nil

                }

                if file.Name.Name != *pkgName {

                        if *verbose {

                                fmt.Printf("\tignored (package %s)\n", file.Name.Name)

                        }

                        return nil

                }

        }

        // parse entire file

        mode := parser.DeclarationErrors

        if *allErrors {

                mode |= parser.SpuriousErrors

        }

        if *printTrace {

                mode |= parser.Trace

        }

        file, err := parser.ParseFile(fset, filename, src, mode)

        if err != nil {

                report(err)

                return nil

        }

        if *printAST {

                ast.Print(fset, file)

        }

        return file

}

func parseStdin(fset *token.FileSet) (files map[string]*ast.File) {

        files = make(map[string]*ast.File)

        src, err := ioutil.ReadAll(os.Stdin)

        if err != nil {

                report(err)

                return

        }

        const filename = ""

        if file := parse(fset, filename, src); file != nil {

                files[filename] = file

        }

        return

}

func parseFiles(fset *token.FileSet, filenames []string) (files map[string]*ast.File) {

        files = make(map[string]*ast.File)

        for _, filename := range filenames {

                src, err := ioutil.ReadFile(filename)

                if err != nil {

                        report(err)

                        continue

                }

                if file := parse(fset, filename, src); file != nil {

                        if files[filename] != nil {

                                report(errors.New(fmt.Sprintf("%q: duplicate file", filename)))

                                continue

                        }

                        files[filename] = file

                }

        }

        return

}

func isGoFilename(filename string) bool {

        // ignore non-Go files

        return !strings.HasPrefix(filename, ".") && strings.HasSuffix(filename, ".go")

}

func processDirectory(dirname string) {

        f, err := os.Open(dirname)

        if err != nil {

                report(err)

                return

        }

        filenames, err := f.Readdirnames(-1)

        f.Close()

        if err != nil {

                report(err)

                // continue since filenames may not be empty

        }

        for i, filename := range filenames {

                filenames[i] = filepath.Join(dirname, filename)

        }

        processFiles(filenames, false)

}

func processFiles(filenames []string, allFiles bool) {

        i := 0

        for _, filename := range filenames {

                switch info, err := os.Stat(filename); {

                case err != nil:

                        report(err)

                case info.IsDir():

                        if allFiles || *recursive {

                                processDirectory(filename)

                        }

                default:

                        if allFiles || isGoFilename(info.Name()) {

                                filenames[i] = filename

                                i++

                        }

                }

        }

        fset := token.NewFileSet()

        processPackage(fset, parseFiles(fset, filenames[0:i]))

}

func processPackage(fset *token.FileSet, files map[string]*ast.File) {

        // make a package (resolve all identifiers)

        pkg, err := ast.NewPackage(fset, files, types.GcImporter, types.Universe)

        if err != nil {

                report(err)

                return

        }

        _, err = types.Check(fset, pkg)

        if err != nil {

                report(err)

        }

}

func main() {

        flag.Usage = usage

        flag.Parse()

        if flag.NArg() == 0 {

                fset := token.NewFileSet()

                processPackage(fset, parseStdin(fset))

        } else {

                processFiles(flag.Args(), true)

        }

        os.Exit(exitCode)

}