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.

/*

        The headscan command extracts comment headings from package files;

        it is used to detect false positives which may require an adjustment

        to the comment formatting heuristics in comment.go.

        Usage: headscan [-root root_directory]

        By default, the $GOROOT/src directory is scanned.

*/

package main

import (

        "bytes"

        "flag"

        "fmt"

        "go/doc"

        "go/parser"

        "go/token"

        "os"

        "path/filepath"

        "runtime"

        "strings"

)

var (

        root    = flag.String("root", filepath.Join(runtime.GOROOT(), "src"), "root of filesystem tree to scan")

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

)

const (

        html_h    = "
"

        html_endh = "\n"

)

func isGoFile(fi os.FileInfo) bool {

        return strings.HasSuffix(fi.Name(), ".go") &&

                !strings.HasSuffix(fi.Name(), "_test.go")

}

func appendHeadings(list []string, comment string) []string {

        var buf bytes.Buffer

        doc.ToHTML(&buf, comment, nil)

        for s := buf.String(); ; {

                i := strings.Index(s, html_h)

                if i < 0 {

                        break

                }

                i += len(html_h)

                j := strings.Index(s, html_endh)

                if j < 0 {

                        list = append(list, s[i:]) // incorrect HTML

                        break

                }

                list = append(list, s[i:j])

                s = s[j+len(html_endh):]

        }

        return list

}

func main() {

        flag.Parse()

        fset := token.NewFileSet()

        nheadings := 0

        err := filepath.Walk(*root, func(path string, fi os.FileInfo, err error) error {

                if !fi.IsDir() {

                        return nil

                }

                pkgs, err := parser.ParseDir(fset, path, isGoFile, parser.ParseComments)

                if err != nil {

                        if *verbose {

                                fmt.Fprintln(os.Stderr, err)

                        }

                        return nil

                }

                for _, pkg := range pkgs {

                        d := doc.New(pkg, path, doc.Mode(0))

                        list := appendHeadings(nil, d.Doc)

                        for _, d := range d.Consts {

                                list = appendHeadings(list, d.Doc)

                        }

                        for _, d := range d.Types {

                                list = appendHeadings(list, d.Doc)

                        }

                        for _, d := range d.Vars {

                                list = appendHeadings(list, d.Doc)

                        }

                        for _, d := range d.Funcs {

                                list = appendHeadings(list, d.Doc)

                        }

                        if len(list) > 0 {

                                // directories may contain multiple packages;

                                // print path and package name

                                fmt.Printf("%s (package %s)\n", path, pkg.Name)

                                for _, h := range list {

                                        fmt.Printf("\t%s\n", h)

                                }

                                nheadings += len(list)

                        }

                }

                return nil

        })

        if err != nil {

                fmt.Fprintln(os.Stderr, err)

                os.Exit(1)

        }

        fmt.Println(nheadings, "headings found")

}