2009-06-16 10:14:06 -06:00
|
|
|
// Copyright 2009 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 (
|
2009-10-27 11:34:31 -06:00
|
|
|
"bytes";
|
|
|
|
"container/vector";
|
|
|
|
"flag";
|
|
|
|
"fmt";
|
|
|
|
"go/ast";
|
|
|
|
"go/doc";
|
|
|
|
"go/parser";
|
|
|
|
"go/printer";
|
|
|
|
"go/scanner";
|
|
|
|
"go/token";
|
|
|
|
"http";
|
|
|
|
"io";
|
|
|
|
"log";
|
|
|
|
"os";
|
|
|
|
pathutil "path";
|
|
|
|
"sort";
|
|
|
|
"strings";
|
|
|
|
"sync";
|
|
|
|
"template";
|
|
|
|
"time";
|
2009-06-16 10:14:06 -06:00
|
|
|
)
|
|
|
|
|
|
|
|
|
2009-10-08 16:14:54 -06:00
|
|
|
const Pkg = "/pkg/" // name for auto-generated package documentation tree
|
2009-06-16 10:14:06 -06:00
|
|
|
|
|
|
|
|
2009-10-22 10:41:38 -06:00
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Support types
|
2009-08-28 12:28:05 -06:00
|
|
|
|
2009-10-22 10:41:38 -06:00
|
|
|
// An RWValue wraps a value and permits mutually exclusive
|
|
|
|
// access to it and records the time the value was last set.
|
|
|
|
type RWValue struct {
|
2009-10-27 11:34:31 -06:00
|
|
|
mutex sync.RWMutex;
|
|
|
|
value interface{};
|
|
|
|
timestamp int64; // time of last set(), in seconds since epoch
|
2009-08-28 12:28:05 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-22 10:41:38 -06:00
|
|
|
func (v *RWValue) set(value interface{}) {
|
|
|
|
v.mutex.Lock();
|
|
|
|
v.value = value;
|
|
|
|
v.timestamp = time.Seconds();
|
|
|
|
v.mutex.Unlock();
|
2009-08-28 12:28:05 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-22 10:41:38 -06:00
|
|
|
func (v *RWValue) get() (interface{}, int64) {
|
|
|
|
v.mutex.RLock();
|
|
|
|
defer v.mutex.RUnlock();
|
|
|
|
return v.value, v.timestamp;
|
2009-08-28 12:28:05 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-22 10:41:38 -06:00
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Globals
|
2009-06-16 10:14:06 -06:00
|
|
|
|
2009-10-22 10:41:38 -06:00
|
|
|
type delayTime struct {
|
|
|
|
RWValue;
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-22 10:41:38 -06:00
|
|
|
func (dt *delayTime) backoff(max int) {
|
|
|
|
dt.mutex.Lock();
|
|
|
|
v := dt.value.(int) * 2;
|
|
|
|
if v > max {
|
|
|
|
v = max;
|
|
|
|
}
|
|
|
|
dt.value = v;
|
|
|
|
dt.mutex.Unlock();
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
var (
|
2009-10-08 16:14:54 -06:00
|
|
|
verbose = flag.Bool("v", false, "verbose mode");
|
2009-06-16 10:14:06 -06:00
|
|
|
|
|
|
|
// file system roots
|
2009-10-08 16:14:54 -06:00
|
|
|
goroot string;
|
|
|
|
pkgroot = flag.String("pkgroot", "src/pkg", "root package source directory (if unrooted, relative to goroot)");
|
|
|
|
tmplroot = flag.String("tmplroot", "lib/godoc", "root template directory (if unrooted, relative to goroot)");
|
2009-06-16 10:14:06 -06:00
|
|
|
|
|
|
|
// layout control
|
2009-10-08 16:14:54 -06:00
|
|
|
tabwidth = flag.Int("tabwidth", 4, "tab width");
|
2009-06-16 10:14:06 -06:00
|
|
|
)
|
|
|
|
|
|
|
|
|
|
|
|
func init() {
|
2009-06-26 21:28:41 -06:00
|
|
|
goroot = os.Getenv("GOROOT");
|
2009-07-02 10:47:25 -06:00
|
|
|
if goroot == "" {
|
2009-06-16 10:14:06 -06:00
|
|
|
goroot = "/home/r/go-release/go";
|
|
|
|
}
|
|
|
|
flag.StringVar(&goroot, "goroot", goroot, "Go root directory");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
2009-10-28 17:19:09 -06:00
|
|
|
// Predicates and small utility functions
|
2009-06-16 10:14:06 -06:00
|
|
|
|
|
|
|
func isGoFile(dir *os.Dir) bool {
|
2009-10-08 16:14:54 -06:00
|
|
|
return dir.IsRegular() &&
|
|
|
|
!strings.HasPrefix(dir.Name, ".") && // ignore .files
|
2009-10-27 11:34:31 -06:00
|
|
|
pathutil.Ext(dir.Name) == ".go";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func isPkgFile(dir *os.Dir) bool {
|
|
|
|
return isGoFile(dir) &&
|
2009-10-08 16:14:54 -06:00
|
|
|
!strings.HasSuffix(dir.Name, "_test.go"); // ignore test files
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func isPkgDir(dir *os.Dir) bool {
|
2009-08-20 10:49:05 -06:00
|
|
|
return dir.IsDirectory() && len(dir.Name) > 0 && dir.Name[0] != '_';
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-28 17:19:09 -06:00
|
|
|
func htmlEscape(s string) string {
|
|
|
|
var buf bytes.Buffer;
|
|
|
|
template.HtmlEscape(&buf, strings.Bytes(s));
|
|
|
|
return buf.String();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-02 10:25:39 -07:00
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Directory trees
|
|
|
|
|
|
|
|
type Directory struct {
|
|
|
|
Path string; // including Name
|
|
|
|
Name string;
|
|
|
|
Subdirs []*Directory
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func newDirTree0(path, name string) *Directory {
|
|
|
|
list, _ := io.ReadDir(path); // ignore errors
|
|
|
|
// determine number of subdirectories n
|
|
|
|
n := 0;
|
|
|
|
for _, d := range list {
|
|
|
|
if isPkgDir(d) {
|
|
|
|
n++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// create Directory node
|
|
|
|
var subdirs []*Directory;
|
|
|
|
if n > 0 {
|
|
|
|
subdirs = make([]*Directory, n);
|
|
|
|
i := 0;
|
|
|
|
for _, d := range list {
|
|
|
|
if isPkgDir(d) {
|
|
|
|
subdirs[i] = newDirTree0(pathutil.Join(path, d.Name), d.Name);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if strings.HasPrefix(path, "src/") {
|
|
|
|
path = path[len("src/") : len(path)];
|
|
|
|
}
|
|
|
|
return &Directory{path, name, subdirs};
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func newDirTree(root string) *Directory {
|
|
|
|
d, err := os.Lstat(root);
|
|
|
|
if err != nil {
|
|
|
|
log.Stderrf("%v", err);
|
|
|
|
return nil;
|
|
|
|
}
|
|
|
|
if !isPkgDir(d) {
|
|
|
|
log.Stderrf("not a package directory: %s", d.Name);
|
|
|
|
return nil;
|
|
|
|
}
|
|
|
|
return newDirTree0(root, d.Name);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-06-16 10:14:06 -06:00
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Parsing
|
|
|
|
|
|
|
|
// A single error in the parsed file.
|
|
|
|
type parseError struct {
|
2009-10-08 16:14:54 -06:00
|
|
|
src []byte; // source before error
|
|
|
|
line int; // line number of error
|
|
|
|
msg string; // error message
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// All the errors in the parsed file, plus surrounding source code.
|
|
|
|
// Each error has a slice giving the source text preceding it
|
|
|
|
// (starting where the last error occurred). The final element in list[]
|
|
|
|
// has msg = "", to give the remainder of the source code.
|
|
|
|
// This data structure is handed to the templates parseerror.txt and parseerror.html.
|
|
|
|
//
|
|
|
|
type parseErrors struct {
|
2009-10-08 16:14:54 -06:00
|
|
|
filename string; // path to file
|
|
|
|
list []parseError; // the errors
|
|
|
|
src []byte; // the file's entire source code
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Parses a file (path) and returns the corresponding AST and
|
|
|
|
// a sorted list (by file position) of errors, if any.
|
|
|
|
//
|
2009-07-16 18:11:18 -06:00
|
|
|
func parse(path string, mode uint) (*ast.File, *parseErrors) {
|
2009-06-16 10:14:06 -06:00
|
|
|
src, err := io.ReadFile(path);
|
|
|
|
if err != nil {
|
2009-10-01 15:08:00 -06:00
|
|
|
log.Stderrf("%v", err);
|
2009-06-16 10:14:06 -06:00
|
|
|
errs := []parseError{parseError{nil, 0, err.String()}};
|
|
|
|
return nil, &parseErrors{path, errs, nil};
|
|
|
|
}
|
|
|
|
|
2009-07-16 18:11:18 -06:00
|
|
|
prog, err := parser.ParseFile(path, src, mode);
|
2009-06-16 10:14:06 -06:00
|
|
|
if err != nil {
|
2009-07-14 17:30:06 -06:00
|
|
|
var errs []parseError;
|
2009-07-14 11:46:18 -06:00
|
|
|
if errors, ok := err.(scanner.ErrorList); ok {
|
2009-07-14 17:30:06 -06:00
|
|
|
// convert error list (already sorted)
|
|
|
|
// TODO(gri) If the file contains //line comments, the errors
|
|
|
|
// may not be sorted in increasing file offset value
|
|
|
|
// which will lead to incorrect output.
|
2009-10-08 16:14:54 -06:00
|
|
|
errs = make([]parseError, len(errors)+1); // +1 for final fragment of source
|
2009-06-16 10:14:06 -06:00
|
|
|
offs := 0;
|
|
|
|
for i, r := range errors {
|
|
|
|
// Should always be true, but check for robustness.
|
|
|
|
if 0 <= r.Pos.Offset && r.Pos.Offset <= len(src) {
|
|
|
|
errs[i].src = src[offs : r.Pos.Offset];
|
|
|
|
offs = r.Pos.Offset;
|
|
|
|
}
|
|
|
|
errs[i].line = r.Pos.Line;
|
|
|
|
errs[i].msg = r.Msg;
|
|
|
|
}
|
2009-10-08 16:14:54 -06:00
|
|
|
errs[len(errors)].src = src[offs:len(src)];
|
2009-06-16 10:14:06 -06:00
|
|
|
} else {
|
2009-07-14 17:30:06 -06:00
|
|
|
// single error of unspecified type
|
|
|
|
errs = make([]parseError, 2);
|
|
|
|
errs[0] = parseError{[]byte{}, 0, err.String()};
|
|
|
|
errs[1].src = src;
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
2009-07-14 17:30:06 -06:00
|
|
|
return nil, &parseErrors{path, errs, src};
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return prog, nil;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-22 10:41:38 -06:00
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// HTML formatting support
|
|
|
|
|
|
|
|
// Styler implements a printer.Styler.
|
|
|
|
type Styler struct {
|
|
|
|
highlight string;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (s *Styler) LineTag(line int) (text []byte, tag printer.HtmlTag) {
|
|
|
|
tag = printer.HtmlTag{fmt.Sprintf(`<a id="L%d">`, line), "</a>"};
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-27 11:34:31 -06:00
|
|
|
func (s *Styler) Comment(c *ast.Comment, line []byte) (text []byte, tag printer.HtmlTag) {
|
2009-10-22 10:41:38 -06:00
|
|
|
text = line;
|
|
|
|
// minimal syntax-coloring of comments for now - people will want more
|
|
|
|
// (don't do anything more until there's a button to turn it on/off)
|
|
|
|
tag = printer.HtmlTag{`<span class="comment">`, "</span>"};
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-27 11:34:31 -06:00
|
|
|
func (s *Styler) BasicLit(x *ast.BasicLit) (text []byte, tag printer.HtmlTag) {
|
2009-10-22 10:41:38 -06:00
|
|
|
text = x.Value;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-27 11:34:31 -06:00
|
|
|
func (s *Styler) Ident(id *ast.Ident) (text []byte, tag printer.HtmlTag) {
|
2009-10-22 10:41:38 -06:00
|
|
|
text = strings.Bytes(id.Value);
|
|
|
|
if s.highlight == id.Value {
|
|
|
|
tag = printer.HtmlTag{"<span class=highlight>", "</span>"};
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-27 11:34:31 -06:00
|
|
|
func (s *Styler) Token(tok token.Token) (text []byte, tag printer.HtmlTag) {
|
2009-10-22 10:41:38 -06:00
|
|
|
text = strings.Bytes(tok.String());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-06-16 10:14:06 -06:00
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Templates
|
|
|
|
|
2009-07-31 19:04:53 -06:00
|
|
|
// Write an AST-node to w; optionally html-escaped.
|
2009-10-27 11:34:31 -06:00
|
|
|
func writeNode(w io.Writer, node interface{}, html bool, styler printer.Styler) {
|
2009-07-31 19:04:53 -06:00
|
|
|
mode := printer.UseSpaces;
|
|
|
|
if html {
|
|
|
|
mode |= printer.GenHTML;
|
|
|
|
}
|
2009-10-27 11:34:31 -06:00
|
|
|
(&printer.Config{mode, *tabwidth, styler}).Fprint(w, node);
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-07-31 19:04:53 -06:00
|
|
|
// Write text to w; optionally html-escaped.
|
|
|
|
func writeText(w io.Writer, text []byte, html bool) {
|
|
|
|
if html {
|
|
|
|
template.HtmlEscape(w, text);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
w.Write(text);
|
|
|
|
}
|
|
|
|
|
2009-06-16 10:14:06 -06:00
|
|
|
|
2009-07-31 19:04:53 -06:00
|
|
|
// Write anything to w; optionally html-escaped.
|
|
|
|
func writeAny(w io.Writer, x interface{}, html bool) {
|
2009-06-16 10:14:06 -06:00
|
|
|
switch v := x.(type) {
|
|
|
|
case []byte:
|
2009-07-31 19:04:53 -06:00
|
|
|
writeText(w, v, html);
|
2009-06-16 10:14:06 -06:00
|
|
|
case string:
|
2009-07-31 19:04:53 -06:00
|
|
|
writeText(w, strings.Bytes(v), html);
|
2009-06-16 10:14:06 -06:00
|
|
|
case ast.Decl:
|
2009-10-22 10:41:38 -06:00
|
|
|
writeNode(w, v, html, nil);
|
2009-06-16 10:14:06 -06:00
|
|
|
case ast.Expr:
|
2009-10-22 10:41:38 -06:00
|
|
|
writeNode(w, v, html, nil);
|
2009-07-31 19:04:53 -06:00
|
|
|
default:
|
|
|
|
if html {
|
|
|
|
var buf bytes.Buffer;
|
|
|
|
fmt.Fprint(&buf, x);
|
2009-09-16 16:15:00 -06:00
|
|
|
writeText(w, buf.Bytes(), true);
|
2009-07-31 19:04:53 -06:00
|
|
|
} else {
|
|
|
|
fmt.Fprint(w, x);
|
|
|
|
}
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Template formatter for "html" format.
|
|
|
|
func htmlFmt(w io.Writer, x interface{}, format string) {
|
2009-07-31 19:04:53 -06:00
|
|
|
writeAny(w, x, true);
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Template formatter for "html-comment" format.
|
|
|
|
func htmlCommentFmt(w io.Writer, x interface{}, format string) {
|
2009-07-31 19:04:53 -06:00
|
|
|
var buf bytes.Buffer;
|
|
|
|
writeAny(&buf, x, false);
|
2009-10-28 17:19:09 -06:00
|
|
|
doc.ToHtml(w, buf.Bytes()); // does html-escaping
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Template formatter for "" (default) format.
|
|
|
|
func textFmt(w io.Writer, x interface{}, format string) {
|
2009-07-31 19:04:53 -06:00
|
|
|
writeAny(w, x, false);
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-02 10:25:39 -07:00
|
|
|
// Template formatter for "dir" format.
|
|
|
|
func dirFmt(w io.Writer, x interface{}, format string) {
|
|
|
|
_ = x.(*Directory); // die quickly if x has the wrong type
|
|
|
|
if err := dirsHtml.Execute(x, w); err != nil {
|
|
|
|
log.Stderrf("dirsHtml.Execute: %s", err);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-08-03 10:53:00 -06:00
|
|
|
// Template formatter for "link" format.
|
|
|
|
func linkFmt(w io.Writer, x interface{}, format string) {
|
2009-10-08 16:14:54 -06:00
|
|
|
type Positioner interface {
|
|
|
|
Pos() token.Position;
|
|
|
|
}
|
2009-08-03 10:53:00 -06:00
|
|
|
if node, ok := x.(Positioner); ok {
|
|
|
|
pos := node.Pos();
|
|
|
|
if pos.IsValid() {
|
|
|
|
// line id's in html-printed source are of the
|
|
|
|
// form "L%d" where %d stands for the line number
|
2009-10-28 17:19:09 -06:00
|
|
|
fmt.Fprintf(w, "/%s#L%d", htmlEscape(pos.Filename), pos.Line);
|
2009-08-03 10:53:00 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-28 17:19:09 -06:00
|
|
|
// The strings in infoClasses must be properly html-escaped.
|
2009-10-27 11:34:31 -06:00
|
|
|
var infoClasses = [nKinds]string{
|
2009-10-27 17:08:12 -06:00
|
|
|
"package", // PackageClause
|
2009-10-27 11:34:31 -06:00
|
|
|
"import", // ImportDecl
|
|
|
|
"const", // ConstDecl
|
|
|
|
"type", // TypeDecl
|
|
|
|
"var", // VarDecl
|
|
|
|
"func", // FuncDecl
|
|
|
|
"method", // MethodDecl
|
|
|
|
"use", // Use
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Template formatter for "infoClass" format.
|
|
|
|
func infoClassFmt(w io.Writer, x interface{}, format string) {
|
2009-10-28 17:19:09 -06:00
|
|
|
fmt.Fprintf(w, infoClasses[x.(SpotInfo).Kind()]); // no html escaping needed
|
2009-10-27 11:34:31 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Template formatter for "infoLine" format.
|
|
|
|
func infoLineFmt(w io.Writer, x interface{}, format string) {
|
|
|
|
info := x.(SpotInfo);
|
|
|
|
line := info.Lori();
|
|
|
|
if info.IsIndex() {
|
|
|
|
index, _ := searchIndex.get();
|
|
|
|
line = index.(*Index).Snippet(line).Line;
|
|
|
|
}
|
|
|
|
fmt.Fprintf(w, "%d", line);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Template formatter for "infoSnippet" format.
|
|
|
|
func infoSnippetFmt(w io.Writer, x interface{}, format string) {
|
|
|
|
info := x.(SpotInfo);
|
|
|
|
text := `<span class="alert">no snippet text available</span>`;
|
|
|
|
if info.IsIndex() {
|
|
|
|
index, _ := searchIndex.get();
|
2009-10-28 17:19:09 -06:00
|
|
|
// no escaping of snippet text needed;
|
|
|
|
// snippet text is escaped when generated
|
2009-10-27 11:34:31 -06:00
|
|
|
text = index.(*Index).Snippet(info.Lori()).Text;
|
|
|
|
}
|
2009-10-28 17:19:09 -06:00
|
|
|
fmt.Fprint(w, text);
|
2009-10-27 11:34:31 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-06-16 10:14:06 -06:00
|
|
|
var fmap = template.FormatterMap{
|
|
|
|
"": textFmt,
|
|
|
|
"html": htmlFmt,
|
|
|
|
"html-comment": htmlCommentFmt,
|
2009-11-02 10:25:39 -07:00
|
|
|
"dir": dirFmt,
|
2009-08-03 10:53:00 -06:00
|
|
|
"link": linkFmt,
|
2009-10-27 11:34:31 -06:00
|
|
|
"infoClass": infoClassFmt,
|
|
|
|
"infoLine": infoLineFmt,
|
|
|
|
"infoSnippet": infoSnippetFmt,
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func readTemplate(name string) *template.Template {
|
|
|
|
path := pathutil.Join(*tmplroot, name);
|
|
|
|
data, err := io.ReadFile(path);
|
|
|
|
if err != nil {
|
|
|
|
log.Exitf("ReadFile %s: %v", path, err);
|
|
|
|
}
|
|
|
|
t, err1 := template.Parse(string(data), fmap);
|
|
|
|
if err1 != nil {
|
|
|
|
log.Exitf("%s: %v", name, err);
|
|
|
|
}
|
|
|
|
return t;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-22 10:41:38 -06:00
|
|
|
var (
|
2009-11-02 10:25:39 -07:00
|
|
|
dirsHtml,
|
2009-10-22 10:41:38 -06:00
|
|
|
godocHtml,
|
|
|
|
packageHtml,
|
|
|
|
packageText,
|
|
|
|
parseerrorHtml,
|
2009-10-27 11:34:31 -06:00
|
|
|
parseerrorText,
|
|
|
|
searchHtml *template.Template;
|
2009-10-22 10:41:38 -06:00
|
|
|
)
|
2009-06-16 10:14:06 -06:00
|
|
|
|
|
|
|
func readTemplates() {
|
|
|
|
// have to delay until after flags processing,
|
|
|
|
// so that main has chdir'ed to goroot.
|
2009-11-02 10:25:39 -07:00
|
|
|
dirsHtml = readTemplate("dirs.html");
|
2009-06-16 10:14:06 -06:00
|
|
|
godocHtml = readTemplate("godoc.html");
|
|
|
|
packageHtml = readTemplate("package.html");
|
|
|
|
packageText = readTemplate("package.txt");
|
|
|
|
parseerrorHtml = readTemplate("parseerror.html");
|
|
|
|
parseerrorText = readTemplate("parseerror.txt");
|
2009-10-27 11:34:31 -06:00
|
|
|
searchHtml = readTemplate("search.html");
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Generic HTML wrapper
|
|
|
|
|
2009-11-02 10:25:39 -07:00
|
|
|
var pkgTree RWValue; // *Directory tree of packages, updated with each sync
|
|
|
|
|
2009-10-27 11:34:31 -06:00
|
|
|
func servePage(c *http.Conn, title, query string, content []byte) {
|
2009-06-16 10:14:06 -06:00
|
|
|
type Data struct {
|
2009-10-27 11:34:31 -06:00
|
|
|
Title string;
|
|
|
|
Timestamp string;
|
|
|
|
Query string;
|
|
|
|
Content []byte;
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
2009-11-02 10:25:39 -07:00
|
|
|
_, ts := pkgTree.get();
|
2009-10-01 15:08:00 -06:00
|
|
|
d := Data{
|
2009-10-27 11:34:31 -06:00
|
|
|
Title: title,
|
|
|
|
Timestamp: time.SecondsToLocalTime(ts).String(),
|
|
|
|
Query: query,
|
|
|
|
Content: content,
|
2009-10-01 15:08:00 -06:00
|
|
|
};
|
|
|
|
|
2009-08-03 10:53:00 -06:00
|
|
|
if err := godocHtml.Execute(&d, c); err != nil {
|
|
|
|
log.Stderrf("godocHtml.Execute: %s", err);
|
|
|
|
}
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func serveText(c *http.Conn, text []byte) {
|
|
|
|
c.SetHeader("content-type", "text/plain; charset=utf-8");
|
|
|
|
c.Write(text);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Files
|
|
|
|
|
2009-10-01 15:08:00 -06:00
|
|
|
var (
|
2009-10-08 16:14:54 -06:00
|
|
|
tagBegin = strings.Bytes("<!--");
|
|
|
|
tagEnd = strings.Bytes("-->");
|
2009-10-01 15:08:00 -06:00
|
|
|
)
|
|
|
|
|
|
|
|
// commentText returns the text of the first HTML comment in src.
|
|
|
|
func commentText(src []byte) (text string) {
|
|
|
|
i := bytes.Index(src, tagBegin);
|
|
|
|
j := bytes.Index(src, tagEnd);
|
|
|
|
if i >= 0 && j >= i+len(tagBegin) {
|
|
|
|
text = string(bytes.TrimSpace(src[i+len(tagBegin) : j]));
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func serveHtmlDoc(c *http.Conn, r *http.Request, filename string) {
|
|
|
|
// get HTML body contents
|
|
|
|
path := pathutil.Join(goroot, filename);
|
|
|
|
src, err := io.ReadFile(path);
|
|
|
|
if err != nil {
|
|
|
|
log.Stderrf("%v", err);
|
|
|
|
http.NotFound(c, r);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// if it's the language spec, add tags to EBNF productions
|
|
|
|
if strings.HasSuffix(path, "go_spec.html") {
|
|
|
|
var buf bytes.Buffer;
|
|
|
|
linkify(&buf, src);
|
|
|
|
src = buf.Bytes();
|
|
|
|
}
|
|
|
|
|
|
|
|
title := commentText(src);
|
2009-10-27 11:34:31 -06:00
|
|
|
servePage(c, title, "", src);
|
2009-10-01 15:08:00 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-06-16 10:14:06 -06:00
|
|
|
func serveParseErrors(c *http.Conn, errors *parseErrors) {
|
|
|
|
// format errors
|
2009-06-29 16:24:23 -06:00
|
|
|
var buf bytes.Buffer;
|
2009-08-03 10:53:00 -06:00
|
|
|
if err := parseerrorHtml.Execute(errors, &buf); err != nil {
|
|
|
|
log.Stderrf("parseerrorHtml.Execute: %s", err);
|
|
|
|
}
|
2009-10-27 11:34:31 -06:00
|
|
|
servePage(c, "Parse errors in source file " + errors.filename, "", buf.Bytes());
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-27 11:34:31 -06:00
|
|
|
func serveGoSource(c *http.Conn, filename string, styler printer.Styler) {
|
2009-10-01 15:08:00 -06:00
|
|
|
path := pathutil.Join(goroot, filename);
|
|
|
|
prog, errors := parse(path, parser.ParseComments);
|
2009-06-16 10:14:06 -06:00
|
|
|
if errors != nil {
|
|
|
|
serveParseErrors(c, errors);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-06-29 16:24:23 -06:00
|
|
|
var buf bytes.Buffer;
|
2009-06-16 10:14:06 -06:00
|
|
|
fmt.Fprintln(&buf, "<pre>");
|
2009-10-27 11:34:31 -06:00
|
|
|
writeNode(&buf, prog, true, styler);
|
2009-06-16 10:14:06 -06:00
|
|
|
fmt.Fprintln(&buf, "</pre>");
|
|
|
|
|
2009-10-27 11:34:31 -06:00
|
|
|
servePage(c, "Source file " + filename, "", buf.Bytes());
|
2009-09-03 10:58:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-08 16:14:54 -06:00
|
|
|
var fileServer = http.FileServer(".", "")
|
2009-06-16 10:14:06 -06:00
|
|
|
|
2009-10-01 15:08:00 -06:00
|
|
|
func serveFile(c *http.Conn, r *http.Request) {
|
|
|
|
path := r.Url.Path;
|
|
|
|
|
2009-06-16 10:14:06 -06:00
|
|
|
// pick off special cases and hand the rest to the standard file server
|
2009-10-01 15:08:00 -06:00
|
|
|
switch ext := pathutil.Ext(path); {
|
|
|
|
case path == "/":
|
|
|
|
serveHtmlDoc(c, r, "doc/root.html");
|
2009-06-16 10:14:06 -06:00
|
|
|
|
2009-10-01 15:08:00 -06:00
|
|
|
case r.Url.Path == "/doc/root.html":
|
2009-06-16 10:14:06 -06:00
|
|
|
// hide landing page from its real name
|
2009-10-01 15:08:00 -06:00
|
|
|
http.NotFound(c, r);
|
|
|
|
|
|
|
|
case ext == ".html":
|
|
|
|
serveHtmlDoc(c, r, path);
|
2009-06-16 10:14:06 -06:00
|
|
|
|
2009-10-01 15:08:00 -06:00
|
|
|
case ext == ".go":
|
2009-10-22 10:41:38 -06:00
|
|
|
serveGoSource(c, path, &Styler{highlight: r.FormValue("h")});
|
2009-06-16 10:14:06 -06:00
|
|
|
|
|
|
|
default:
|
2009-10-01 15:08:00 -06:00
|
|
|
// TODO:
|
|
|
|
// - need to decide what to serve and what not to serve
|
|
|
|
// - don't want to download files, want to see them
|
|
|
|
fileServer.ServeHTTP(c, r);
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Packages
|
|
|
|
|
|
|
|
// TODO if we don't plan to use the directory information, simplify to []string
|
|
|
|
type dirList []*os.Dir
|
|
|
|
|
2009-10-08 16:14:54 -06:00
|
|
|
func (d dirList) Len() int {
|
|
|
|
return len(d);
|
|
|
|
}
|
|
|
|
func (d dirList) Less(i, j int) bool {
|
|
|
|
return d[i].Name < d[j].Name;
|
|
|
|
}
|
|
|
|
func (d dirList) Swap(i, j int) {
|
|
|
|
d[i], d[j] = d[j], d[i];
|
|
|
|
}
|
2009-06-16 10:14:06 -06:00
|
|
|
|
|
|
|
|
2009-07-29 18:01:09 -06:00
|
|
|
func pkgName(filename string) string {
|
|
|
|
file, err := parse(filename, parser.PackageClauseOnly);
|
|
|
|
if err != nil || file == nil {
|
|
|
|
return "";
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
2009-07-29 18:01:09 -06:00
|
|
|
return file.Name.Value;
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-07-29 18:01:09 -06:00
|
|
|
type PageInfo struct {
|
2009-10-08 16:14:54 -06:00
|
|
|
PDoc *doc.PackageDoc; // nil if no package found
|
|
|
|
Dirs dirList; // nil if no subdirectories found
|
2009-07-29 18:01:09 -06:00
|
|
|
}
|
2009-06-16 10:14:06 -06:00
|
|
|
|
|
|
|
|
2009-07-29 18:01:09 -06:00
|
|
|
// getPageInfo returns the PageInfo for a given package directory.
|
|
|
|
// If there is no corresponding package in the directory,
|
|
|
|
// PageInfo.PDoc is nil. If there are no subdirectories,
|
|
|
|
// PageInfo.Dirs is nil.
|
|
|
|
//
|
|
|
|
func getPageInfo(path string) PageInfo {
|
|
|
|
// the path is relative to *pkgroot
|
|
|
|
dirname := pathutil.Join(*pkgroot, path);
|
2009-06-16 10:14:06 -06:00
|
|
|
|
2009-07-16 18:11:18 -06:00
|
|
|
// the package name is the directory name within its parent
|
2009-07-29 18:01:09 -06:00
|
|
|
_, pkgname := pathutil.Split(dirname);
|
|
|
|
|
|
|
|
// filter function to select the desired .go files and
|
|
|
|
// collect subdirectories
|
|
|
|
var subdirlist vector.Vector;
|
|
|
|
subdirlist.Init(0);
|
|
|
|
filter := func(d *os.Dir) bool {
|
2009-10-27 11:34:31 -06:00
|
|
|
if isPkgFile(d) {
|
2009-07-29 18:01:09 -06:00
|
|
|
// Some directories contain main packages: Only accept
|
|
|
|
// files that belong to the expected package so that
|
|
|
|
// parser.ParsePackage doesn't return "multiple packages
|
|
|
|
// found" errors.
|
|
|
|
return pkgName(dirname + "/" + d.Name) == pkgname;
|
|
|
|
}
|
|
|
|
if isPkgDir(d) {
|
|
|
|
subdirlist.Push(d);
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
2009-07-29 18:01:09 -06:00
|
|
|
return false;
|
|
|
|
};
|
|
|
|
|
|
|
|
// get package AST
|
|
|
|
pkg, err := parser.ParsePackage(dirname, filter, parser.ParseComments);
|
|
|
|
if err != nil {
|
2009-10-01 15:08:00 -06:00
|
|
|
// TODO: parse errors should be shown instead of an empty directory
|
2009-07-29 18:01:09 -06:00
|
|
|
log.Stderr(err);
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
2009-07-29 18:01:09 -06:00
|
|
|
// convert and sort subdirectory list, if any
|
2009-06-16 10:14:06 -06:00
|
|
|
var subdirs dirList;
|
2009-07-29 18:01:09 -06:00
|
|
|
if subdirlist.Len() > 0 {
|
|
|
|
subdirs = make(dirList, subdirlist.Len());
|
|
|
|
for i := 0; i < subdirlist.Len(); i++ {
|
|
|
|
subdirs[i] = subdirlist.At(i).(*os.Dir);
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
sort.Sort(subdirs);
|
|
|
|
}
|
|
|
|
|
2009-07-29 18:01:09 -06:00
|
|
|
// compute package documentation
|
|
|
|
var pdoc *doc.PackageDoc;
|
|
|
|
if pkg != nil {
|
2009-07-30 19:13:55 -06:00
|
|
|
ast.PackageExports(pkg);
|
2009-10-08 16:14:54 -06:00
|
|
|
pdoc = doc.NewPackageDoc(pkg, pathutil.Clean(path)); // no trailing '/' in importpath
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
2009-07-29 18:01:09 -06:00
|
|
|
return PageInfo{pdoc, subdirs};
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func servePkg(c *http.Conn, r *http.Request) {
|
|
|
|
path := r.Url.Path;
|
2009-10-08 16:14:54 -06:00
|
|
|
path = path[len(Pkg):len(path)];
|
2009-06-16 10:14:06 -06:00
|
|
|
|
2009-07-29 18:01:09 -06:00
|
|
|
// canonicalize URL path and redirect if necessary
|
2009-10-08 16:14:54 -06:00
|
|
|
if canonical := pathutil.Clean(Pkg+path) + "/"; r.Url.Path != canonical {
|
2009-06-16 10:14:06 -06:00
|
|
|
http.Redirect(c, canonical, http.StatusMovedPermanently);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-07-29 18:01:09 -06:00
|
|
|
info := getPageInfo(path);
|
2009-06-16 10:14:06 -06:00
|
|
|
|
2009-06-29 16:24:23 -06:00
|
|
|
var buf bytes.Buffer;
|
2009-10-28 17:19:09 -06:00
|
|
|
if r.FormValue("f") == "text" {
|
2009-08-03 10:53:00 -06:00
|
|
|
if err := packageText.Execute(info, &buf); err != nil {
|
2009-06-16 10:14:06 -06:00
|
|
|
log.Stderrf("packageText.Execute: %s", err);
|
|
|
|
}
|
2009-09-16 16:15:00 -06:00
|
|
|
serveText(c, buf.Bytes());
|
2009-06-16 10:14:06 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-08-03 10:53:00 -06:00
|
|
|
if err := packageHtml.Execute(info, &buf); err != nil {
|
2009-06-16 10:14:06 -06:00
|
|
|
log.Stderrf("packageHtml.Execute: %s", err);
|
|
|
|
}
|
|
|
|
|
|
|
|
if path == "" {
|
2009-10-08 16:14:54 -06:00
|
|
|
path = "."; // don't display an empty path
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
2009-10-01 15:08:00 -06:00
|
|
|
title := "Directory " + path;
|
|
|
|
if info.PDoc != nil {
|
|
|
|
title = "Package " + info.PDoc.PackageName;
|
|
|
|
}
|
|
|
|
|
2009-10-27 11:34:31 -06:00
|
|
|
servePage(c, title, "", buf.Bytes());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-02 10:25:39 -07:00
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Directory tree
|
|
|
|
|
|
|
|
// TODO(gri): Temporary - integrate with package serving.
|
|
|
|
|
|
|
|
func serveTree(c *http.Conn, r *http.Request) {
|
|
|
|
dir, _ := pkgTree.get();
|
|
|
|
|
|
|
|
var buf bytes.Buffer;
|
|
|
|
dirFmt(&buf, dir, "");
|
|
|
|
|
|
|
|
servePage(c, "Package tree", "", buf.Bytes());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-27 11:34:31 -06:00
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Search
|
|
|
|
|
|
|
|
var searchIndex RWValue
|
|
|
|
|
|
|
|
type SearchResult struct {
|
|
|
|
Query string;
|
|
|
|
Hit *LookupResult;
|
|
|
|
Alt *AltWords;
|
|
|
|
Accurate bool;
|
|
|
|
Legend []string;
|
|
|
|
}
|
|
|
|
|
|
|
|
func search(c *http.Conn, r *http.Request) {
|
|
|
|
query := r.FormValue("q");
|
|
|
|
var result SearchResult;
|
|
|
|
|
|
|
|
if index, timestamp := searchIndex.get(); index != nil {
|
|
|
|
result.Query = query;
|
|
|
|
result.Hit, result.Alt = index.(*Index).Lookup(query);
|
2009-11-02 10:25:39 -07:00
|
|
|
_, ts := pkgTree.get();
|
2009-10-27 11:34:31 -06:00
|
|
|
result.Accurate = timestamp >= ts;
|
|
|
|
result.Legend = &infoClasses;
|
|
|
|
}
|
|
|
|
|
|
|
|
var buf bytes.Buffer;
|
|
|
|
if err := searchHtml.Execute(result, &buf); err != nil {
|
|
|
|
log.Stderrf("searchHtml.Execute: %s", err);
|
|
|
|
}
|
|
|
|
|
|
|
|
var title string;
|
|
|
|
if result.Hit != nil {
|
|
|
|
title = fmt.Sprintf(`Results for query %q`, query);
|
|
|
|
} else {
|
|
|
|
title = fmt.Sprintf(`No results found for query %q`, query);
|
|
|
|
}
|
|
|
|
|
|
|
|
servePage(c, title, query, buf.Bytes());
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Server
|
|
|
|
|
2009-10-30 11:58:53 -06:00
|
|
|
func registerPublicHandlers(mux *http.ServeMux) {
|
|
|
|
mux.Handle(Pkg, http.HandlerFunc(servePkg));
|
2009-11-02 10:25:39 -07:00
|
|
|
mux.Handle("/tree", http.HandlerFunc(serveTree)); // TODO(gri): integrate with package serving
|
2009-10-30 11:58:53 -06:00
|
|
|
mux.Handle("/search", http.HandlerFunc(search));
|
|
|
|
mux.Handle("/", http.HandlerFunc(serveFile));
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-30 11:58:53 -06:00
|
|
|
// Indexing goroutine.
|
|
|
|
func indexer() {
|
|
|
|
for {
|
2009-11-02 10:25:39 -07:00
|
|
|
_, ts := pkgTree.get();
|
2009-10-30 11:58:53 -06:00
|
|
|
if _, timestamp := searchIndex.get(); timestamp < ts {
|
|
|
|
// index possibly out of date - make a new one
|
|
|
|
// (could use a channel to send an explicit signal
|
|
|
|
// from the sync goroutine, but this solution is
|
|
|
|
// more decoupled, trivial, and works well enough)
|
|
|
|
start := time.Nanoseconds();
|
|
|
|
index := NewIndex(".");
|
|
|
|
stop := time.Nanoseconds();
|
|
|
|
searchIndex.set(index);
|
|
|
|
if *verbose {
|
|
|
|
secs := float64((stop-start)/1e6)/1e3;
|
|
|
|
nwords, nspots := index.Size();
|
|
|
|
log.Stderrf("index updated (%gs, %d unique words, %d spots)", secs, nwords, nspots);
|
2009-10-27 11:34:31 -06:00
|
|
|
}
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
2009-10-30 11:58:53 -06:00
|
|
|
time.Sleep(1*60e9); // try once a minute
|
2009-08-03 10:53:00 -06:00
|
|
|
}
|
2009-06-16 10:14:06 -06:00
|
|
|
}
|
2009-10-30 11:58:53 -06:00
|
|
|
|