Skip to content

G
go
Commit a893db87 authored by Robert Griesemer's avatar Robert Griesemer
Browse files
Options

gofmt (final resting place TBD): 

- replacement for pretty; app to format a single .go file

printer.go (pkg/go/printer):
- replacement for astprinter.go; implements AST printing
- also replaces pkg/go/ast/format.go for now

cleanups:
- removed/saved away old code

R=r,rsc,iant
DELTA=2833  (1183 added, 1628 deleted, 22 changed)
OCL=30226
CL=30306
parent c2faeac8
Show whitespace changes
Inline Side-by-side
Showing with 1211 additions and 1525 deletions
src/pkg/Make.deps
View file @ a893db87
......@@ -16,9 +16,10 @@ exec.install: os.install strings.install
exvar.install: fmt.install http.install io.install log.install strconv.install sync.install
flag.install: fmt.install os.install strconv.install
fmt.install: io.install os.install reflect.install strconv.install utf8.install
go/ast.install: datafmt.install go/token.install io.install os.install unicode.install utf8.install
go/ast.install: go/token.install unicode.install utf8.install
go/doc.install: container/vector.install fmt.install go/ast.install go/token.install io.install once.install regexp.install sort.install strings.install template.install
go/parser.install: container/vector.install fmt.install go/ast.install go/scanner.install go/token.install io.install os.install
go/printer.install: fmt.install go/ast.install go/token.install io.install os.install reflect.install
go/scanner.install: go/token.install strconv.install unicode.install utf8.install
go/token.install: strconv.install
hash.install: io.install
......
src/pkg/Makefile
View file @ a893db87
......@@ -33,6 +33,7 @@ DIRS=\
go/ast\
go/doc\
go/parser\
go/printer\
go/scanner\
go/token\
hash\
......
src/pkg/go/ast/Makefile
View file @ a893db87
......@@ -34,21 +34,14 @@ coverage: packages
O1=\
ast.$O\
O2=\
format.$O\
phases: a1 a2
phases: a1
_obj$D/ast.a: phases
a1: $(O1)
$(AR) grc _obj$D/ast.a ast.$O
rm -f $(O1)
a2: $(O2)
$(AR) grc _obj$D/ast.a format.$O
rm -f $(O2)
newpkg: clean
mkdir -p _obj$D
......@@ -56,7 +49,6 @@ newpkg: clean
$(O1): newpkg
$(O2): a1
$(O3): a2
nuke: clean
rm -f $(GOROOT)/pkg/$(GOOS)_$(GOARCH)$D/ast.a
......
src/pkg/go/ast/format.go deleted 100644 → 0
View file @ c2faeac8
// 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 ast
import (
"datafmt";
"go/ast";
"go/token";
"io";
"os";
)
// Format is a customized datafmt.Format for printing of ASTs.
type Format datafmt.Format;
// ----------------------------------------------------------------------------
// Custom formatters
// The AST-specific formatting state is maintained by a state variable.
type state struct {
// for now we have very little state
// TODO maintain list of unassociated comments
optSemi bool
}
func (s *state) Copy() datafmt.Environment {
copy := *s;
return ©
}
func isValidPos(s *datafmt.State, value interface{}, ruleName string) bool {
pos := value.(token.Position);
return pos.IsValid();
}
func isSend(s *datafmt.State, value interface{}, ruleName string) bool {
return value.(ast.ChanDir) & ast.SEND != 0;
}
func isRecv(s *datafmt.State, value interface{}, ruleName string) bool {
return value.(ast.ChanDir) & ast.RECV != 0;
}
func isMultiLineComment(s *datafmt.State, value interface{}, ruleName string) bool {
return value.([]byte)[1] == '*';
}
func clearOptSemi(s *datafmt.State, value interface{}, ruleName string) bool {
s.Env().(*state).optSemi = false;
return true;
}
func setOptSemi(s *datafmt.State, value interface{}, ruleName string) bool {
s.Env().(*state).optSemi = true;
return true;
}
func optSemi(s *datafmt.State, value interface{}, ruleName string) bool {
if !s.Env().(*state).optSemi {
s.Write([]byte{';'});
}
return true;
}
var fmap = datafmt.FormatterMap {
"isValidPos": isValidPos,
"isSend": isSend,
"isRecv": isRecv,
"isMultiLineComment": isMultiLineComment,
"/": clearOptSemi,
"clearOptSemi": clearOptSemi,
"setOptSemi": setOptSemi,
"optSemi": optSemi,
}
// ----------------------------------------------------------------------------
// Printing
// NewFormat parses a datafmt format specification from a file
// and adds AST-specific custom formatter rules. The result is
// the customized format or an os.Error, if any.
//
func NewFormat(filename string) (Format, os.Error) {
src, err := io.ReadFile(filename);
if err != nil {
return nil, err;
}
f, err := datafmt.Parse(src, fmap);
return Format(f), err;
}
// Fprint formats each AST node provided as argument according to the
// format f and writes to standard output. The result is the total number
// of bytes written and an os.Error, if any.
//
func (f Format) Fprint(w io.Writer, nodes ...) (int, os.Error) {
var s state;
return datafmt.Format(f).Fprint(w, &s, nodes);
}
// Fprint formats each AST node provided as argument according to the
// format f and writes to w. The result is the total number of bytes
// written and an os.Error, if any.
//
func (f Format) Print(nodes ...) (int, os.Error) {
return f.Fprint(os.Stdout, nodes);
}
src/pkg/go/printer/Makefile 0 → 100644
View file @ a893db87
# 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.
# DO NOT EDIT. Automatically generated by gobuild.
# gobuild -m >Makefile
D=/go/
include $(GOROOT)/src/Make.$(GOARCH)
AR=gopack
default: packages
clean:
rm -rf *.[$(OS)] *.a [$(OS)].out _obj
test: packages
gotest
coverage: packages
gotest
6cov -g `pwd` | grep -v '_test\.go:'
%.$O: %.go
$(GC) -I_obj $*.go
%.$O: %.c
$(CC) $*.c
%.$O: %.s
$(AS) $*.s
O1=\
printer.$O\
phases: a1
_obj$D/printer.a: phases
a1: $(O1)
$(AR) grc _obj$D/printer.a printer.$O
rm -f $(O1)
newpkg: clean
mkdir -p _obj$D
$(AR) grc _obj$D/printer.a
$(O1): newpkg
$(O2): a1
nuke: clean
rm -f $(GOROOT)/pkg/$(GOOS)_$(GOARCH)$D/printer.a
packages: _obj$D/printer.a
install: packages
test -d $(GOROOT)/pkg && mkdir -p $(GOROOT)/pkg/$(GOOS)_$(GOARCH)$D
cp _obj$D/printer.a $(GOROOT)/pkg/$(GOOS)_$(GOARCH)$D/printer.a
src/pkg/go/printer/printer.go 0 → 100644
View file @ a893db87
// 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.
// The printer package implements printing of AST nodes.
package printer
import (
"fmt";
"go/ast";
"go/token";
"io";
"os";
"reflect";
)
// Printing is controlled with these flags supplied
// to Fprint via the mode parameter.
//
const (
ExportsOnly uint = 1 << iota; // print exported code only
DocComments; // print documentation comments
OptCommas; // print optional commas
OptSemis; // print optional semicolons
)
type printer struct {
// configuration (does not change after initialization)
output io.Writer;
mode uint;
errors chan os.Error;
comments ast.Comments; // list of unassociated comments; or nil
// current state (changes during printing)
written int; // number of bytes written
level int; // function nesting level; 0 = package scope, 1 = top-level function scope, etc.
indent int; // indent level
pos token.Position; // output position (possibly estimated) in "AST space"
// comments
cindex int; // the current comment index
cpos token.Position; // the position of the next comment
}
func (p *printer) hasComment(pos token.Position) bool {
return p.cpos.Offset < pos.Offset;
}
func (p *printer) nextComment() {
p.cindex++;
if p.comments != nil && p.cindex < len(p.comments) && p.comments[p.cindex] != nil {
p.cpos = p.comments[p.cindex].Pos();
} else {
p.cpos = token.Position{1<<30, 1<<30, 1}; // infinite
}
}
func (p *printer) setComments(comments ast.Comments) {
p.comments = comments;
p.cindex = -1;
p.nextComment();
}
func (p *printer) init(output io.Writer, mode uint) {
p.output = output;
p.mode = mode;
p.errors = make(chan os.Error);
p.setComments(nil);
}
var (
blank = []byte{' '};
tab = []byte{'\t'};
newline = []byte{'\n'};
formfeed = []byte{'\f'};
)
// Writing to p.output is done with write0 which also handles errors.
// It should only be called by write.
//
func (p *printer) write0(data []byte) {
n, err := p.output.Write(data);
p.written += n;
if err != nil {
p.errors <- err;
}
}
func (p *printer) write(data []byte) {
i0 := 0;
for i, b := range data {
if b == '\n' || b == '\f' {
// write segment ending in a newline/formfeed followed by indentation
// TODO should convert '\f' into '\n' if the output is not going through
// tabwriter
p.write0(data[i0 : i+1]);
for j := p.indent; j > 0; j-- {
p.write0(tab);
}
i0 = i+1;
// update p.pos
p.pos.Offset += i+1 - i0 + p.indent;
p.pos.Line++;
p.pos.Column = p.indent + 1;
}
}
// write remaining segment
p.write0(data[i0 : len(data)]);
// update p.pos
n := len(data) - i0;
p.pos.Offset += n;
p.pos.Column += n;
}
// Reduce contiguous sequences of '\t' in a []byte to a single '\t'.
func untabify(src []byte) []byte {
dst := make([]byte, len(src));
j := 0;
for i, c := range src {
if c != '\t' || i == 0 || src[i-1] != '\t' {
dst[j] = c;
j++;
}
}
return dst[0 : j];
}
func (p *printer) adjustSpacingAndMergeComments() {
for ; p.hasComment(p.pos); p.nextComment() {
// we have a comment that comes before the current position
comment := p.comments[p.cindex];
p.write(untabify(comment.Text));
// TODO
// - classify comment and provide better formatting
// - add extra newlines if so indicated by source positions
}
}
func (p *printer) print(args ...) {
v := reflect.NewValue(args).(reflect.StructValue);
for i := 0; i < v.Len(); i++ {
p.adjustSpacingAndMergeComments();
f := v.Field(i);
switch x := f.Interface().(type) {
case int:
// indentation delta
p.indent += x;
if p.indent < 0 {
panic("print: negative indentation");
}
case []byte:
p.write(x);
case string:
p.write(io.StringBytes(x));
case token.Token:
p.write(io.StringBytes(x.String()));
case token.Position:
// set current position
p.pos = x;
default:
panicln("print: unsupported argument type", f.Type().String());
}
}
}
// ----------------------------------------------------------------------------
// Predicates
func (p *printer) optSemis() bool {
return p.mode & OptSemis != 0;
}
func (p *printer) exportsOnly() bool {
return p.mode & ExportsOnly != 0;
}
// The isVisibleX predicates return true if X should produce any output
// given the printing mode and depending on whether X contains exported
// names.
func (p *printer) isVisibleIdent(x *ast.Ident) bool {
// identifiers in local scopes (p.level > 0) are always visible
// if the surrounding code is printed in the first place
return !p.exportsOnly() || x.IsExported() || p.level > 0;
}
func (p *printer) isVisibleIdentList(list []*ast.Ident) bool {
for _, x := range list {
if p.isVisibleIdent(x) {
return true;
}
}
return false;
}
func (p *printer) isVisibleFieldList(list []*ast.Field) bool {
for _, f := range list {
if len(f.Names) == 0 {
// anonymous field
// TODO should only return true if the anonymous field
// type is visible (for now be conservative and
// print it so that the generated code is valid)
return true;
}
if p.isVisibleIdentList(f.Names) {
return true;
}
}
return false;
}
func (p *printer) isVisibleSpec(spec ast.Spec) bool {
switch s := spec.(type) {
case *ast.ImportSpec:
return !p.exportsOnly();
case *ast.ValueSpec:
return p.isVisibleIdentList(s.Names);
case *ast.TypeSpec:
return p.isVisibleIdent(s.Name);
}
panic("unreachable");
return false;
}
func (p *printer) isVisibleSpecList(list []ast.Spec) bool {
for _, s := range list {
if p.isVisibleSpec(s) {
return true;
}
}
return false;
}
func (p *printer) isVisibleDecl(decl ast.Decl) bool {
switch d := decl.(type) {
case *ast.BadDecl:
return false;
case *ast.GenDecl:
return p.isVisibleSpecList(d.Specs);
case *ast.FuncDecl:
return p.isVisibleIdent(d.Name);
}
panic("unreachable");
return false;
}
// ----------------------------------------------------------------------------
// Printing of common AST nodes.
func (p *printer) comment(c *ast.Comment) {
if c != nil {
text := c.Text;
if text[1] == '/' {
// //-style comment - dont print the '\n'
// TODO scanner should probably not include the '\n' in this case
text = text[0 : len(text)-1];
}
p.print(tab, c.Pos(), text); // tab-separated trailing comment
}
}
func (p *printer) doc(d ast.Comments) {
if p.mode & DocComments != 0 {
for _, c := range d {
p.print(c.Pos(), c.Text);
}
}
}
func (p *printer) expr(x ast.Expr) bool
func (p *printer) identList(list []*ast.Ident) {
needsComma := false;
for i, x := range list {
if p.isVisibleIdent(x) {
if needsComma {
p.print(token.COMMA, blank);
}
p.expr(x);
needsComma = true;
}
}
}
func (p *printer) exprList(list []ast.Expr) {
for i, x := range list {
if i > 0 {
p.print(token.COMMA, blank);
}
p.expr(x);
}
}
func (p *printer) parameters(list []*ast.Field) {
p.print(token.LPAREN);
if len(list) > 0 {
for i, par := range list {
if i > 0 {
p.print(token.COMMA, blank);
}
p.identList(par.Names); // p.level > 0; all identifiers will be printed
if len(par.Names) > 0 {
// at least one identifier
p.print(blank);
};
p.expr(par.Type);
}
}
p.print(token.RPAREN);
}
func (p *printer) signature(params, result []*ast.Field) {
p.parameters(params);
if result != nil {
p.print(blank);
if len(result) == 1 && result[0].Names == nil {
// single anonymous result; no ()'s unless it's a function type
f := result[0];
if _, isFtyp := f.Type.(*ast.FuncType); !isFtyp {
p.expr(f.Type);
return;
}
}
p.parameters(result);
}
}
// Returns true if the field list ends in a closing brace.
func (p *printer) fieldList(lbrace token.Position, list []*ast.Field, rbrace token.Position, isInterface bool) bool {
hasBody := p.isVisibleFieldList(list);
if !lbrace.IsValid() || p.exportsOnly() && !hasBody {
// forward declaration without {}'s or no visible exported fields
// (in all other cases, the {}'s must be printed even if there are
// no fields, otherwise the type is incorrect)
return false; // no {}'s
}
p.print(blank, lbrace, token.LBRACE);
if hasBody {
p.print(+1, newline);
var needsSemi bool;
var lastWasAnon bool; // true if the previous line was an anonymous field
var lastComment *ast.Comment; // the comment from the previous line
for _, f := range list {
hasNames := p.isVisibleIdentList(f.Names);
isAnon := len(f.Names) == 0;
if hasNames || isAnon {
// at least one visible identifier or anonymous field
// TODO this is conservative - see isVisibleFieldList
if needsSemi {
p.print(token.SEMICOLON);
p.comment(lastComment);
if lastWasAnon == isAnon {
// previous and current line have same structure;
// continue with existing columns
p.print(newline);
} else {
// previous and current line have different structure;
// flush tabwriter and start new columns (the "type
// column" on a line with named fields may line up
// with the "trailing comment column" on a line with
// an anonymous field, leading to bad alignment)
p.print(formfeed);
}
}
p.doc(f.Doc);
if hasNames {
p.identList(f.Names);
p.print(tab);
}
if isInterface {
if ftyp, isFtyp := f.Type.(*ast.FuncType); isFtyp {
// methods
p.signature(ftyp.Params, ftyp.Results);
} else {
// embedded interface
p.expr(f.Type);
}
} else {
p.expr(f.Type);
if f.Tag != nil && !p.exportsOnly() {
p.print(tab);
p.expr(&ast.StringList{f.Tag});
}
}
needsSemi = true;
lastWasAnon = isAnon;
lastComment = f.Comment;
}
}
if p.optSemis() {
p.print(token.SEMICOLON);
}
p.comment(lastComment);
p.print(-1, newline);
}
p.print(rbrace, token.RBRACE);
return true; // field list with {}'s
}
// ----------------------------------------------------------------------------
// Expressions
func (p *printer) stmt(s ast.Stmt) (optSemi bool)
// Returns true if a separating semicolon is optional.
func (p *printer) expr1(expr ast.Expr, prec1 int) (optSemi bool) {
p.print(expr.Pos());
switch x := expr.(type) {
case *ast.BadExpr:
p.print("BadExpr");
case *ast.Ident:
p.print(x.Value);
case *ast.BinaryExpr:
prec := x.Op.Precedence();
if prec < prec1 {
p.print(token.LPAREN);
}
p.expr1(x.X, prec);
p.print(blank, x.OpPos, x.Op, blank);
p.expr1(x.Y, prec);
if prec < prec1 {
p.print(token.RPAREN);
}
case *ast.KeyValueExpr:
p.expr(x.Key);
p.print(blank, x.Colon, token.COLON, blank);
p.expr(x.Value);
case *ast.StarExpr:
p.print(token.MUL);
p.expr(x.X);
case *ast.UnaryExpr:
prec := token.UnaryPrec;
if prec < prec1 {
p.print(token.LPAREN);
}
p.print(x.Op);
if x.Op == token.RANGE {
p.print(blank);
}
p.expr1(x.X, prec);
if prec < prec1 {
p.print(token.RPAREN);
}
case *ast.IntLit:
p.print(x.Value);
case *ast.FloatLit:
p.print(x.Value);
case *ast.CharLit:
p.print(x.Value);
case *ast.StringLit:
p.print(x.Value);
case *ast.StringList:
for i, x := range x.Strings {
if i > 0 {
p.print(blank);
}
p.expr(x);
}
case *ast.FuncLit:
p.level++;
p.expr(x.Type);
p.print(blank);
p.stmt(x.Body);
p.level--;
case *ast.ParenExpr:
p.print(token.LPAREN);
p.expr(x.X);
p.print(x.Rparen, token.RPAREN);
case *ast.SelectorExpr:
p.expr1(x.X, token.HighestPrec);
p.print(token.PERIOD);
p.expr1(x.Sel, token.HighestPrec);
case *ast.TypeAssertExpr:
p.expr1(x.X, token.HighestPrec);
p.print(token.PERIOD, token.LPAREN);
p.expr(x.Type);
p.print(token.RPAREN);
case *ast.IndexExpr:
p.expr1(x.X, token.HighestPrec);
p.print(token.LBRACK);
p.expr(x.Index);
if x.End != nil {
p.print(blank, token.COLON, blank);
p.expr(x.End);
}
p.print(token.RBRACK);
case *ast.CallExpr:
p.expr1(x.Fun, token.HighestPrec);
p.print(x.Lparen, token.LPAREN);
p.exprList(x.Args);
p.print(x.Rparen, token.RPAREN);
case *ast.CompositeLit:
p.expr1(x.Type, token.HighestPrec);
p.print(x.Lbrace, token.LBRACE);
p.exprList(x.Elts);
if p.mode & OptCommas != 0 {
p.print(token.COMMA);
}
p.print(x.Rbrace, token.RBRACE);
case *ast.Ellipsis:
p.print(token.ELLIPSIS);
case *ast.ArrayType:
p.print(token.LBRACK);
if x.Len != nil {
p.expr(x.Len);
}
p.print(token.RBRACK);
p.expr(x.Elt);
case *ast.StructType:
p.print(token.STRUCT);
optSemi = p.fieldList(x.Lbrace, x.Fields, x.Rbrace, false);
case *ast.FuncType:
p.print(token.FUNC);
p.signature(x.Params, x.Results);
case *ast.InterfaceType:
p.print(token.INTERFACE);
optSemi = p.fieldList(x.Lbrace, x.Methods, x.Rbrace, true);
case *ast.MapType:
p.print(token.MAP, blank, token.LBRACK);
p.expr(x.Key);
p.print(token.RBRACK);
p.expr(x.Value);
case *ast.ChanType:
switch x.Dir {
case ast.SEND | ast.RECV:
p.print(token.CHAN);
case ast.RECV:
p.print(token.ARROW, token.CHAN);
case ast.SEND:
p.print(token.CHAN, blank, token.ARROW);
}
p.print(blank);
p.expr(x.Value);
default:
panic("unreachable");
}
return optSemi;
}
// Returns true if a separating semicolon is optional.
func (p *printer) expr(x ast.Expr) bool {
return p.expr1(x, token.LowestPrec);
}
// ----------------------------------------------------------------------------
// Statements
func (p *printer) decl(decl ast.Decl) (optSemi bool)
// Print the statement list indented, but without a newline after the last statement.
func (p *printer) stmtList(list []ast.Stmt) {
if len(list) > 0 {
p.print(+1, newline);
optSemi := false;
for i, s := range list {
if i > 0 {
if !optSemi || p.optSemis() {
// semicolon is required
p.print(token.SEMICOLON);
}
p.print(newline);
}
optSemi = p.stmt(s);
}
if p.optSemis() {
p.print(token.SEMICOLON);
}
p.print(-1);
}
}
func (p *printer) block(s *ast.BlockStmt) {
p.print(s.Pos(), token.LBRACE);
if len(s.List) > 0 {
p.stmtList(s.List);
p.print(newline);
}
p.print(s.Rbrace, token.RBRACE);
}
func (p *printer) switchBlock(s *ast.BlockStmt) {
p.print(s.Pos(), token.LBRACE);
if len(s.List) > 0 {
for i, s := range s.List {
// s is one of *ast.CaseClause, *ast.TypeCaseClause, *ast.CommClause;
p.print(newline);
p.stmt(s);
}
p.print(newline);
}
p.print(s.Rbrace, token.RBRACE);
}
func (p *printer) controlClause(isForStmt bool, init ast.Stmt, expr ast.Expr, post ast.Stmt) {
if init == nil && post == nil {
// no semicolons required
if expr != nil {
p.print(blank);
p.expr(expr);
}
} else {
// all semicolons required
// (they are not separators, print them explicitly)
p.print(blank);
if init != nil {
p.stmt(init);
}
p.print(token.SEMICOLON, blank);
if expr != nil {
p.expr(expr);
}
if isForStmt {
p.print(token.SEMICOLON, blank);
if post != nil {
p.stmt(post);
}
}
}
}
// Returns true if a separating semicolon is optional.
func (p *printer) stmt(stmt ast.Stmt) (optSemi bool) {
p.print(stmt.Pos());
switch s := stmt.(type) {
case *ast.BadStmt:
p.print("BadStmt");
case *ast.DeclStmt:
optSemi = p.decl(s.Decl);
case *ast.EmptyStmt:
// nothing to do
case *ast.LabeledStmt:
p.print(-1, newline);
p.expr(s.Label);
p.print(token.COLON, tab, +1);
optSemi = p.stmt(s.Stmt);
case *ast.ExprStmt:
p.expr(s.X);
case *ast.IncDecStmt:
p.expr(s.X);
p.print(s.Tok);
case *ast.AssignStmt:
p.exprList(s.Lhs);
p.print(blank, s.TokPos, s.Tok, blank);
p.exprList(s.Rhs);
case *ast.GoStmt:
p.print(token.GO, blank);
p.expr(s.Call);
case *ast.DeferStmt:
p.print(token.DEFER, blank);
p.expr(s.Call);
case *ast.ReturnStmt:
p.print(token.RETURN);
if s.Results != nil {
p.print(blank);
p.exprList(s.Results);
}
case *ast.BranchStmt:
p.print(s.Tok);
if s.Label != nil {
p.print(blank);
p.expr(s.Label);
}
case *ast.BlockStmt:
p.block(s);
optSemi = true;
case *ast.IfStmt:
p.print(token.IF);
p.controlClause(false, s.Init, s.Cond, nil);
p.print(blank);
p.block(s.Body);
optSemi = true;
if s.Else != nil {
p.print(blank, token.ELSE, blank);
optSemi = p.stmt(s.Else);
}
case *ast.CaseClause:
if s.Values != nil {
p.print(token.CASE, blank);
p.exprList(s.Values);
} else {
p.print(token.DEFAULT);
}
p.print(s.Colon, token.COLON);
p.stmtList(s.Body);
case *ast.SwitchStmt:
p.print(token.SWITCH);
p.controlClause(false, s.Init, s.Tag, nil);
p.print(blank);
p.switchBlock(s.Body);
optSemi = true;
case *ast.TypeCaseClause:
if s.Type != nil {
p.print(token.CASE, blank);
p.expr(s.Type);
} else {
p.print(token.DEFAULT);
}
p.print(s.Colon, token.COLON);
p.stmtList(s.Body);
case *ast.TypeSwitchStmt:
p.print(token.SWITCH);
if s.Init != nil {
p.print(blank);
p.stmt(s.Init);
p.print(token.SEMICOLON);
}
p.print(blank);
p.stmt(s.Assign);
p.print(blank);
p.switchBlock(s.Body);
optSemi = true;
case *ast.CommClause:
if s.Rhs != nil {
p.print(token.CASE, blank);
if s.Lhs != nil {
p.expr(s.Lhs);
p.print(blank, s.Tok, blank);
}
p.expr(s.Rhs);
} else {
p.print(token.DEFAULT);
}
p.print(s.Colon, token.COLON);
p.stmtList(s.Body);
case *ast.SelectStmt:
p.print(token.SELECT, blank);
p.switchBlock(s.Body);
optSemi = true;
case *ast.ForStmt:
p.print(token.FOR);
p.controlClause(true, s.Init, s.Cond, s.Post);
p.print(blank);
p.block(s.Body);
optSemi = true;
case *ast.RangeStmt:
p.print(token.FOR, blank);
p.expr(s.Key);
if s.Value != nil {
p.print(token.COMMA, blank);
p.expr(s.Value);
}
p.print(blank, s.TokPos, s.Tok, blank, token.RANGE, blank);
p.expr(s.X);
p.print(blank);
p.block(s.Body);
optSemi = true;
default:
panic("unreachable");
}
return optSemi;
}
// ----------------------------------------------------------------------------
// Declarations
// Returns true if a separating semicolon is optional.
func (p *printer) spec(spec ast.Spec) (optSemi bool) {
switch s := spec.(type) {
case *ast.ImportSpec:
p.doc(s.Doc);
if s.Name != nil {
p.expr(s.Name);
}
// TODO fix for longer package names
p.print(tab, s.Path[0].Pos(), s.Path[0].Value);
case *ast.ValueSpec:
p.doc(s.Doc);
p.identList(s.Names);
if s.Type != nil {
p.print(blank); // TODO switch to tab? (indent problem with structs)
p.expr(s.Type);
}
if s.Values != nil {
p.print(tab, token.ASSIGN, blank);
p.exprList(s.Values);
}
case *ast.TypeSpec:
p.doc(s.Doc);
p.expr(s.Name);
p.print(blank); // TODO switch to tab? (but indent problem with structs)
optSemi = p.expr(s.Type);
default:
panic("unreachable");
}
return optSemi;
}
// Returns true if a separating semicolon is optional.
func (p *printer) decl(decl ast.Decl) (optSemi bool) {
switch d := decl.(type) {
case *ast.BadDecl:
p.print(d.Pos(), "BadDecl");
case *ast.GenDecl:
p.doc(d.Doc);
p.print(d.Pos(), d.Tok, blank);
if d.Lparen.IsValid() {
// group of parenthesized declarations
p.print(d.Lparen, token.LPAREN);
if p.isVisibleSpecList(d.Specs) {
p.print(+1, newline);
semi := false;
for _, s := range d.Specs {
if p.isVisibleSpec(s) {
if semi {
p.print(token.SEMICOLON, newline);
}
p.spec(s);
semi = true;
}
}
if p.optSemis() {
p.print(token.SEMICOLON);
}
p.print(-1, newline);
}
p.print(d.Rparen, token.RPAREN);
optSemi = true;
} else {
// single declaration
optSemi = p.spec(d.Specs[0]);
}
case *ast.FuncDecl:
p.level++;
p.doc(d.Doc);
p.print(d.Pos(), token.FUNC, blank);
if recv := d.Recv; recv != nil {
// method: print receiver
p.print(token.LPAREN);
if len(recv.Names) > 0 {
p.expr(recv.Names[0]);
p.print(blank);
}
p.expr(recv.Type);
p.print(token.RPAREN, blank);
}
p.expr(d.Name);
p.signature(d.Type.Params, d.Type.Results);
if !p.exportsOnly() && d.Body != nil {
p.print(blank);
p.stmt(d.Body);
}
p.level--;
default:
panic("unreachable");
}
return optSemi;
}
// ----------------------------------------------------------------------------
// Programs
func (p *printer) program(prog *ast.Program) {
// set unassociated comments if all code is printed
if !p.exportsOnly() {
// TODO enable this once comments are properly interspersed
//p.setComments(prog.Comments);
}
p.doc(prog.Doc);
p.print(prog.Pos(), token.PACKAGE, blank);
p.expr(prog.Name);
for _, d := range prog.Decls {
if p.isVisibleDecl(d) {
p.print(newline, newline);
p.decl(d);
if p.optSemis() {
p.print(token.SEMICOLON);
}
}
}
}
// ----------------------------------------------------------------------------
// Public interface
// Fprint "pretty-prints" an AST node to output and returns the number of
// bytes written, and an error, if any. The node type must be *ast.Program,
// or assignment-compatible to ast.Expr, ast.Decl, or ast.Stmt. Printing is
// controlled by the mode parameter. For best results, the output should be
// a tabwriter.Writer.
//
func Fprint(output io.Writer, node interface{}, mode uint) (int, os.Error) {
var p printer;
p.init(output, mode);
go func() {
switch n := node.(type) {
case ast.Expr:
p.expr(n);
case ast.Stmt:
p.stmt(n);
case ast.Decl:
p.decl(n);
case *ast.Program:
p.program(n);
default:
p.errors <- os.NewError("unsupported node type");
}
p.print(newline);
p.errors <- nil; // no errors
}();
err := <-p.errors; // wait for completion of goroutine
return p.written, err;
}
usr/gri/pretty/Makefile
View file @ a893db87
......@@ -4,34 +4,26 @@
include $(GOROOT)/src/Make.$(GOARCH)
all: untab godoc pretty
untab: untab.$O
$(LD) -o untab untab.$O
all: godoc gofmt
godoc: godoc.$O
$(LD) -o godoc godoc.$O
pretty: pretty.$O
$(LD) -o pretty pretty.$O
gofmt: gofmt.$O
$(LD) -o gofmt gofmt.$O
test: pretty
test: gofmt
./test.sh
smoketest: pretty
./test.sh astprinter.go
smoketest: gofmt
./test.sh $(GOROOT)/src/pkg/go/printer/printer.go
install: pretty godoc untab
cp godoc $(HOME)/bin/godoc
cp pretty $(HOME)/bin/pretty
cp untab $(HOME)/bin/untab
cp gofmt $(HOME)/bin/gofmt
clean:
rm -f pretty untab godoc *.$O *.a 6.out *~
godoc.$O: astprinter.$O
pretty.$O: astprinter.$O
rm -f godoc gofmt *.$O *.a 6.out *~
%.$O: %.go
$(GC) $(F) $<
usr/gri/pretty/astprinter.go deleted 100644 → 0
View file @ c2faeac8
// 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 astPrinter
import (
"flag";
"fmt";
"go/ast";
"go/token";
"io";
"os";
)
var (
debug = flag.Bool("ast_debug", false, "print debugging information");
// layout control
newlines = flag.Bool("ast_newlines", false, "respect newlines in source");
maxnewlines = flag.Int("ast_maxnewlines", 3, "max. number of consecutive newlines");
// formatting control
optsemicolons = flag.Bool("ast_optsemicolons", false, "print optional semicolons");
)
// When we don't have a position use noPos.
var noPos token.Position;
// ----------------------------------------------------------------------------
// Elementary support
func unimplemented() {
panic("unimplemented");
}
func unreachable() {
panic("unreachable");
}
func assert(pred bool) {
if !pred {
panic("assertion failed");
}
}
func hasExportedNames(names []*ast.Ident) bool {
for i, name := range names {
if name.IsExported() {
return true;
}
}
return false;
}
// ----------------------------------------------------------------------------
// TokenPrinter
// TODO This is not yet used - should fix this.
// An implementation of a TokenPrinter may be provided when
// initializing an AST Printer. It is used to print tokens.
//
type TokenPrinter interface {
PrintLit(w io.Writer, tok token.Token, value []byte);
PrintIdent(w io.Writer, value string);
PrintToken(w io.Writer, token token.Token);
PrintComment(w io.Writer, value []byte);
}
type defaultPrinter struct {}
func (p defaultPrinter) PrintLit(w io.Writer, tok token.Token, value []byte) {
w.Write(value);
}
func (p defaultPrinter) PrintIdent(w io.Writer, value string) {
fmt.Fprint(w, value);
}
func (p defaultPrinter) PrintToken(w io.Writer, token token.Token) {
fmt.Fprint(w, token.String());
}
func (p defaultPrinter) PrintComment(w io.Writer, value []byte) {
w.Write(value);
}
// ----------------------------------------------------------------------------
// ASTPrinter
// Separators - printed in a delayed fashion, depending on context.
const (
none = iota;
blank;
tab;
comma;
semicolon;
)
// Semantic states - control formatting.
const (
normal = iota;
opening_scope; // controls indentation, scope level
closing_scope; // controls indentation, scope level
inside_list; // controls extra line breaks
)
type Printer struct {
// output
text io.Writer;
// token printing
tprinter TokenPrinter;
// formatting control
html bool;
full bool; // if false, print interface only; print all otherwise
// comments
comments []*ast.Comment; // the list of unassociated comments
cindex int; // the current comment index
cpos token.Position; // the position of the next comment
// current state
lastpos token.Position; // position after last string
level int; // scope level
indentation int; // indentation level (may be different from scope level)
// formatting parameters
opt_semi bool; // // true if semicolon separator is optional in statement list
separator int; // pending separator
newlines int; // pending newlines
// semantic state
state int; // current semantic state
laststate int; // state for last string
// expression precedence
prec int;
}
func (P *Printer) hasComment(pos token.Position) bool {
return P.cpos.Offset < pos.Offset;
}
func (P *Printer) nextComments() {
P.cindex++;
if P.comments != nil && P.cindex < len(P.comments) && P.comments[P.cindex] != nil {
P.cpos = P.comments[P.cindex].Pos();
} else {
P.cpos = token.Position{1<<30, 1<<30, 1}; // infinite
}
}
func (P *Printer) Init(text io.Writer, tprinter TokenPrinter, comments []*ast.Comment, html bool) {
// writers
P.text = text;
// token printing
if tprinter != nil {
P.tprinter = tprinter;
} else {
P.tprinter = defaultPrinter{};
}
// formatting control
P.html = html;
// comments
P.comments = comments;
P.cindex = -1;
P.nextComments();
// formatting parameters & semantic state initialized correctly by default
// expression precedence
P.prec = token.LowestPrec;
}
// ----------------------------------------------------------------------------
// Printing support
func (P *Printer) htmlEscape(s string) string {
if P.html {
var esc string;
for i := 0; i < len(s); i++ {
switch s[i] {
case '<': esc = "&lt;";
case '&': esc = "&amp;";
default: continue;
}
return s[0 : i] + esc + P.htmlEscape(s[i+1 : len(s)]);
}
}
return s;
}
// Reduce contiguous sequences of '\t' in a string to a single '\t'.
func untabify(s string) string {
for i := 0; i < len(s); i++ {
if s[i] == '\t' {
j := i;
for j < len(s) && s[j] == '\t' {
j++;
}
if j-i > 1 { // more then one tab
return s[0 : i+1] + untabify(s[j : len(s)]);
}
}
}
return s;
}
func (P *Printer) Printf(format string, s ...) {
n, err := fmt.Fprintf(P.text, format, s);
if err != nil {
panic("print error - exiting");
}
}
func (P *Printer) newline(n int) {
if n > 0 {
m := int(*maxnewlines);
if n > m {
n = m;
}
for n > 0 {
P.Printf("\n");
n--;
}
for i := P.indentation; i > 0; i-- {
P.Printf("\t");
}
}
}
func (P *Printer) TaggedString(pos token.Position, tag, s, endtag string) {
// use estimate for pos if we don't have one
offs := pos.Offset;
if pos.Line == 0 {
offs = P.lastpos.Offset;
}
// --------------------------------
// print pending separator, if any
// - keep track of white space printed for better comment formatting
// TODO print white space separators after potential comments and newlines
// (currently, we may get trailing white space before a newline)
trailing_char := 0;
switch P.separator {
case none: // nothing to do
case blank:
P.Printf(" ");
trailing_char = ' ';
case tab:
P.Printf("\t");
trailing_char = '\t';
case comma:
P.Printf(",");
if P.newlines == 0 {
P.Printf(" ");
trailing_char = ' ';
}
case semicolon:
if P.level > 0 { // no semicolons at level 0
P.Printf(";");
if P.newlines == 0 {
P.Printf(" ");
trailing_char = ' ';
}
}
default: panic("UNREACHABLE");
}
P.separator = none;
// --------------------------------
// interleave comments, if any
nlcount := 0;
if P.full {
for ; P.hasComment(pos); P.nextComments() {
// we have a comment that comes before the string
comment := P.comments[P.cindex];
ctext := string(comment.Text); // TODO get rid of string conversion here
// classify comment (len(ctext) >= 2)
//-style comment
if nlcount > 0 || P.cpos.Offset == 0 {
// only white space before comment on this line
// or file starts with comment
// - indent
if !*newlines && P.cpos.Offset != 0 {
nlcount = 1;
}
P.newline(nlcount);
nlcount = 0;
} else {
// black space before comment on this line
if ctext[1] == '/' {
//-style comment
// - put in next cell unless a scope was just opened
// in which case we print 2 blanks (otherwise the
// entire scope gets indented like the next cell)
if P.laststate == opening_scope {
switch trailing_char {
case ' ': P.Printf(" "); // one space already printed
case '\t': // do nothing
default: P.Printf(" ");
}
} else {
if trailing_char != '\t' {
P.Printf("\t");
}
}
} else {
/*-style comment */
// - print surrounded by blanks
if trailing_char == 0 {
P.Printf(" ");
}
ctext += " ";
}
}
// print comment
if *debug {
P.Printf("[%d]", P.cpos.Offset);
}
// calling untabify increases the change for idempotent output
// since tabs in comments are also interpreted by tabwriter
P.Printf("%s", P.htmlEscape(untabify(ctext)));
}
// At this point we may have nlcount > 0: In this case we found newlines
// that were not followed by a comment. They are recognized (or not) when
// printing newlines below.
}
// --------------------------------
// interpret state
// (any pending separator or comment must be printed in previous state)
switch P.state {
case normal:
case opening_scope:
case closing_scope:
P.indentation--;
case inside_list:
default:
panic("UNREACHABLE");
}
// --------------------------------
// print pending newlines
if *newlines && (P.newlines > 0 || P.state == inside_list) && nlcount > P.newlines {
// Respect additional newlines in the source, but only if we
// enabled this feature (newlines.BVal()) and we are expecting
// newlines (P.newlines > 0 || P.state == inside_list).
// Otherwise - because we don't have all token positions - we
// get funny formatting.
P.newlines = nlcount;
}
nlcount = 0;
P.newline(P.newlines);
P.newlines = 0;
// --------------------------------
// print string
if *debug {
P.Printf("[%d]", pos);
}
P.Printf("%s%s%s", tag, P.htmlEscape(s), endtag);
// --------------------------------
// interpret state
switch P.state {
case normal:
case opening_scope:
P.level++;
P.indentation++;
case closing_scope:
P.level--;
case inside_list:
default:
panic("UNREACHABLE");
}
P.laststate = P.state;
P.state = none;
// --------------------------------
// done
P.opt_semi = false;
pos.Offset += len(s); // rough estimate
pos.Column += len(s); // rough estimate
P.lastpos = pos;
}
func (P *Printer) String(pos token.Position, s string) {
P.TaggedString(pos, "", s, "");
}
func (P *Printer) Token(pos token.Position, tok token.Token) {
P.String(pos, tok.String());
//P.TaggedString(pos, "<b>", tok.String(), "</b>");
}
func (P *Printer) Error(pos token.Position, tok token.Token, msg string) {
fmt.Printf("\ninternal printing error: pos = %d, tok = %s, %s\n", pos.Offset, tok.String(), msg);
panic();
}
// An astPrinter implements io.Writer.
// TODO this is not yet used.
func (P *Printer) Write(p []byte) (n int, err os.Error) {
// TODO
// - no string conversion every time
// - return proper results
P.String(noPos, string(p));
return len(p), nil;
}
// ----------------------------------------------------------------------------
// HTML support
func (P *Printer) HtmlIdentifier(x *ast.Ident) {
P.String(x.Pos(), x.Value);
/*
obj := x.Obj;
if P.html && obj.Kind != symbolTable.NONE {
// depending on whether we have a declaration or use, generate different html
// - no need to htmlEscape ident
id := utils.IntToString(obj.Id, 10);
if x.Loc_ == obj.Pos {
// probably the declaration of x
P.TaggedString(x.Loc_, `<a name="id` + id + `">`, obj.Ident, `</a>`);
} else {
// probably not the declaration of x
P.TaggedString(x.Loc_, `<a href="#id` + id + `">`, obj.Ident, `</a>`);
}
} else {
P.String(x.Loc_, obj.Ident);
}
*/
}
func (P *Printer) HtmlPackageName(pos token.Position, name string) {
if P.html {
sname := name[1 : len(name)-1]; // strip quotes TODO do this elsewhere eventually
// TODO CAPITAL HACK BELOW FIX THIS
P.TaggedString(pos, `"<a href="/src/pkg/` + sname + `.go">`, sname, `</a>"`);
} else {
P.String(pos, name);
}
}
// ----------------------------------------------------------------------------
// Support
func (P *Printer) Expr(x ast.Expr)
func (P *Printer) Idents(list []*ast.Ident, full bool) int {
n := 0;
for i, x := range list {
if n > 0 {
P.Token(noPos, token.COMMA);
P.separator = blank;
P.state = inside_list;
}
if full || x.IsExported() {
P.Expr(x);
n++;
}
}
return n;
}
func (P *Printer) Exprs(list []ast.Expr) {
for i, x := range list {
if i > 0 {
P.Token(noPos, token.COMMA);
P.separator = blank;
P.state = inside_list;
}
P.Expr(x);
}
}
func (P *Printer) Parameters(list []*ast.Field) {
P.Token(noPos, token.LPAREN);
if len(list) > 0 {
for i, par := range list {
if i > 0 {
P.separator = comma;
}
n := P.Idents(par.Names, true);
if n > 0 {
P.separator = blank
};
P.Expr(par.Type);
}
}
P.Token(noPos, token.RPAREN);
}
// Returns the separator (semicolon or none) required if
// the type is terminating a declaration or statement.
func (P *Printer) Signature(params, result []*ast.Field) {
P.Parameters(params);
if result != nil {
P.separator = blank;
if len(result) == 1 && result[0].Names == nil {
// single anonymous result
// => no parentheses needed unless it's a function type
fld := result[0];
if dummy, is_ftyp := fld.Type.(*ast.FuncType); !is_ftyp {
P.Expr(fld.Type);
return;
}
}
P.Parameters(result);
}
}
func (P *Printer) Fields(lbrace token.Position, list []*ast.Field, rbrace token.Position, is_interface bool) {
P.state = opening_scope;
P.separator = blank;
P.Token(lbrace, token.LBRACE);
if len(list) > 0 {
P.newlines = 1;
for i, fld := range list {
if i > 0 {
P.separator = semicolon;
P.newlines = 1;
}
n := P.Idents(fld.Names, P.full);
if n > 0 {
// at least one identifier
P.separator = tab
};
if n > 0 || len(fld.Names) == 0 {
// at least one identifier or anonymous field
if is_interface {
if ftyp, is_ftyp := fld.Type.(*ast.FuncType); is_ftyp {
P.Signature(ftyp.Params, ftyp.Results);
} else {
P.Expr(fld.Type);
}
} else {
P.Expr(fld.Type);
if fld.Tag != nil {
P.separator = tab;
P.Expr(&ast.StringList{fld.Tag});
}
}
}
}
P.newlines = 1;
}
P.state = closing_scope;
P.Token(rbrace, token.RBRACE);
P.opt_semi = true;
}
// ----------------------------------------------------------------------------
// Expressions
func (P *Printer) Expr1(x ast.Expr, prec1 int)
func (P *Printer) Stmt(s ast.Stmt)
func (P *Printer) DoBadExpr(x *ast.BadExpr) {
P.String(noPos, "BadExpr");
}
func (P *Printer) DoIdent(x *ast.Ident) {
P.HtmlIdentifier(x);
}
func (P *Printer) DoBinaryExpr(x *ast.BinaryExpr) {
prec := x.Op.Precedence();
if prec < P.prec {
P.Token(noPos, token.LPAREN);
}
P.Expr1(x.X, prec);
P.separator = blank;
P.Token(x.OpPos, x.Op);
P.separator = blank;
P.Expr1(x.Y, prec);
if prec < P.prec {
P.Token(noPos, token.RPAREN);
}
}
func (P *Printer) DoKeyValueExpr(x *ast.KeyValueExpr) {
P.Expr(x.Key);
P.separator = blank;
P.Token(x.Colon, token.COLON);
P.separator = blank;
P.Expr(x.Value);
}
func (P *Printer) DoStarExpr(x *ast.StarExpr) {
P.Token(x.Pos(), token.MUL);
P.Expr(x.X);
}
func (P *Printer) DoUnaryExpr(x *ast.UnaryExpr) {
prec := token.UnaryPrec;
if prec < P.prec {
P.Token(noPos, token.LPAREN);
}
P.Token(x.Pos(), x.Op);
if x.Op == token.RANGE {
P.separator = blank;
}
P.Expr1(x.X, prec);
if prec < P.prec {
P.Token(noPos, token.RPAREN);
}
}
func (P *Printer) DoIntLit(x *ast.IntLit) {
// TODO get rid of string conversion here
P.String(x.Pos(), string(x.Value));
}
func (P *Printer) DoFloatLit(x *ast.FloatLit) {
// TODO get rid of string conversion here
P.String(x.Pos(), string(x.Value));
}
func (P *Printer) DoCharLit(x *ast.CharLit) {
// TODO get rid of string conversion here
P.String(x.Pos(), string(x.Value));
}
func (P *Printer) DoStringLit(x *ast.StringLit) {
// TODO get rid of string conversion here
P.String(x.Pos(), string(x.Value));
}
func (P *Printer) DoStringList(x *ast.StringList) {
for i, x := range x.Strings {
if i > 0 {
P.separator = blank;
}
P.DoStringLit(x);
}
}
func (P *Printer) DoFuncType(x *ast.FuncType)
func (P *Printer) DoFuncLit(x *ast.FuncLit) {
P.DoFuncType(x.Type);
P.separator = blank;
P.Stmt(x.Body);
P.opt_semi = false; // BUG 6g or spec
P.newlines = 0;
}
func (P *Printer) DoParenExpr(x *ast.ParenExpr) {
P.Token(x.Pos(), token.LPAREN);
P.Expr(x.X);
P.Token(x.Rparen, token.RPAREN);
}
func (P *Printer) DoSelectorExpr(x *ast.SelectorExpr) {
P.Expr1(x.X, token.HighestPrec);
P.Token(noPos, token.PERIOD);
P.Expr1(x.Sel, token.HighestPrec);
}
func (P *Printer) DoTypeAssertExpr(x *ast.TypeAssertExpr) {
P.Expr1(x.X, token.HighestPrec);
P.Token(noPos, token.PERIOD);
P.Token(noPos, token.LPAREN);
P.Expr(x.Type);
P.Token(noPos, token.RPAREN);
}
func (P *Printer) DoIndexExpr(x *ast.IndexExpr) {
P.Expr1(x.X, token.HighestPrec);
P.Token(noPos, token.LBRACK);
P.Expr(x.Index);
if x.End != nil {
P.Token(noPos, token.COLON);
P.Expr(x.End);
}
P.Token(noPos, token.RBRACK);
}
func (P *Printer) DoCallExpr(x *ast.CallExpr) {
P.Expr1(x.Fun, token.HighestPrec);
P.Token(x.Lparen, token.LPAREN);
P.Exprs(x.Args);
P.Token(x.Rparen, token.RPAREN);
}
func (P *Printer) DoCompositeLit(x *ast.CompositeLit) {
P.Expr1(x.Type, token.HighestPrec);
P.Token(x.Lbrace, token.LBRACE);
P.Exprs(x.Elts);
P.Token(x.Rbrace, token.RBRACE);
}
func (P *Printer) DoEllipsis(x *ast.Ellipsis) {
P.Token(x.Pos(), token.ELLIPSIS);
}
func (P *Printer) DoArrayType(x *ast.ArrayType) {
P.Token(x.Pos(), token.LBRACK);
if x.Len != nil {
P.Expr(x.Len);
}
P.Token(noPos, token.RBRACK);
P.Expr(x.Elt);
}
func (P *Printer) DoStructType(x *ast.StructType) {
P.Token(x.Pos(), token.STRUCT);
if x.Fields != nil {
P.Fields(x.Lbrace, x.Fields, x.Rbrace, false);
}
}
func (P *Printer) DoFuncType(x *ast.FuncType) {
P.Token(x.Pos(), token.FUNC);
P.Signature(x.Params, x.Results);
}
func (P *Printer) DoInterfaceType(x *ast.InterfaceType) {
P.Token(x.Pos(), token.INTERFACE);
if x.Methods != nil {
P.Fields(x.Lbrace, x.Methods, x.Rbrace, true);
}
}
func (P *Printer) DoMapType(x *ast.MapType) {
P.Token(x.Pos(), token.MAP);
P.separator = blank;
P.Token(noPos, token.LBRACK);
P.Expr(x.Key);
P.Token(noPos, token.RBRACK);
P.Expr(x.Value);
}
func (P *Printer) DoChanType(x *ast.ChanType) {
switch x.Dir {
case ast.SEND | ast.RECV:
P.Token(x.Pos(), token.CHAN);
case ast.RECV:
P.Token(x.Pos(), token.ARROW);
P.Token(noPos, token.CHAN);
case ast.SEND:
P.Token(x.Pos(), token.CHAN);
P.separator = blank;
P.Token(noPos, token.ARROW);
}
P.separator = blank;
P.Expr(x.Value);
}
func (P *Printer) Expr1(x ast.Expr, prec1 int) {
if x == nil {
return; // empty expression list
}
saved_prec := P.prec;
P.prec = prec1;
x.Visit(P);
P.prec = saved_prec;
}
func (P *Printer) Expr(x ast.Expr) {
P.Expr1(x, token.LowestPrec);
}
// ----------------------------------------------------------------------------
// Statements
func (P *Printer) Stmt(s ast.Stmt) {
s.Visit(P);
}
func (P *Printer) DoBadStmt(s *ast.BadStmt) {
panic();
}
func (P *Printer) Decl(d ast.Decl);
func (P *Printer) DoDeclStmt(s *ast.DeclStmt) {
P.Decl(s.Decl);
}
func (P *Printer) DoEmptyStmt(s *ast.EmptyStmt) {
P.String(s.Pos(), "");
}
func (P *Printer) DoLabeledStmt(s *ast.LabeledStmt) {
P.indentation--;
P.Expr(s.Label);
P.Token(noPos, token.COLON);
P.indentation++;
// TODO be more clever if s.Stmt is a labeled stat as well
P.separator = tab;
P.Stmt(s.Stmt);
}
func (P *Printer) DoExprStmt(s *ast.ExprStmt) {
P.Expr(s.X);
}
func (P *Printer) DoIncDecStmt(s *ast.IncDecStmt) {
P.Expr(s.X);
P.Token(noPos, s.Tok);
}
func (P *Printer) DoAssignStmt(s *ast.AssignStmt) {
P.Exprs(s.Lhs);
P.separator = blank;
P.Token(s.TokPos, s.Tok);
P.separator = blank;
P.Exprs(s.Rhs);
}
func (P *Printer) DoGoStmt(s *ast.GoStmt) {
P.Token(s.Pos(), token.GO);
P.separator = blank;
P.Expr(s.Call);
}
func (P *Printer) DoDeferStmt(s *ast.DeferStmt) {
P.Token(s.Pos(), token.DEFER);
P.separator = blank;
P.Expr(s.Call);
}
func (P *Printer) DoReturnStmt(s *ast.ReturnStmt) {
P.Token(s.Pos(), token.RETURN);
P.separator = blank;
P.Exprs(s.Results);
}
func (P *Printer) DoBranchStmt(s *ast.BranchStmt) {
P.Token(s.Pos(), s.Tok);
if s.Label != nil {
P.separator = blank;
P.Expr(s.Label);
}
}
func (P *Printer) StatementList(list []ast.Stmt) {
if list != nil {
for i, s := range list {
if i == 0 {
P.newlines = 1;
} else { // i > 0
if !P.opt_semi || *optsemicolons {
// semicolon is required
P.separator = semicolon;
}
}
P.Stmt(s);
P.newlines = 1;
P.state = inside_list;
}
}
}
/*
func (P *Printer) Block(list []ast.Stmt, indent bool) {
P.state = opening_scope;
P.Token(b.Pos_, b.Tok);
if !indent {
P.indentation--;
}
P.StatementList(b.List);
if !indent {
P.indentation++;
}
if !*optsemicolons {
P.separator = none;
}
P.state = closing_scope;
if b.Tok == token.LBRACE {
P.Token(b.Rbrace, token.RBRACE);
P.opt_semi = true;
} else {
P.String(noPos, ""); // process closing_scope state transition!
}
}
*/
func (P *Printer) DoBlockStmt(s *ast.BlockStmt) {
P.state = opening_scope;
P.Token(s.Pos(), token.LBRACE);
P.StatementList(s.List);
if !*optsemicolons {
P.separator = none;
}
P.state = closing_scope;
P.Token(s.Rbrace, token.RBRACE);
P.opt_semi = true;
}
func (P *Printer) ControlClause(isForStmt bool, init ast.Stmt, expr ast.Expr, post ast.Stmt) {
P.separator = blank;
if init == nil && post == nil {
// no semicolons required
if expr != nil {
P.Expr(expr);
}
} else {
// all semicolons required
// (they are not separators, print them explicitly)
if init != nil {
P.Stmt(init);
P.separator = none;
}
P.Token(noPos, token.SEMICOLON);
P.separator = blank;
if expr != nil {
P.Expr(expr);
P.separator = none;
}
if isForStmt {
P.Token(noPos, token.SEMICOLON);
P.separator = blank;
if post != nil {
P.Stmt(post);
}
}
}
P.separator = blank;
}
func (P *Printer) DoIfStmt(s *ast.IfStmt) {
P.Token(s.Pos(), token.IF);
P.ControlClause(false, s.Init, s.Cond, nil);
P.Stmt(s.Body);
if s.Else != nil {
P.separator = blank;
P.Token(noPos, token.ELSE);
P.separator = blank;
P.Stmt(s.Else);
}
}
func (P *Printer) DoCaseClause(s *ast.CaseClause) {
if s.Values != nil {
P.Token(s.Pos(), token.CASE);
P.separator = blank;
P.Exprs(s.Values);
} else {
P.Token(s.Pos(), token.DEFAULT);
}
P.Token(s.Colon, token.COLON);
P.indentation++;
P.StatementList(s.Body);
P.indentation--;
P.newlines = 1;
}
func (P *Printer) DoSwitchStmt(s *ast.SwitchStmt) {
P.Token(s.Pos(), token.SWITCH);
P.ControlClause(false, s.Init, s.Tag, nil);
P.Stmt(s.Body);
}
func (P *Printer) DoTypeCaseClause(s *ast.TypeCaseClause) {
if s.Type != nil {
P.Token(s.Pos(), token.CASE);
P.separator = blank;
P.Expr(s.Type);
} else {
P.Token(s.Pos(), token.DEFAULT);
}
P.Token(s.Colon, token.COLON);
P.indentation++;
P.StatementList(s.Body);
P.indentation--;
P.newlines = 1;
}
func (P *Printer) DoTypeSwitchStmt(s *ast.TypeSwitchStmt) {
P.Token(s.Pos(), token.SWITCH);
P.separator = blank;
if s.Init != nil {
P.Stmt(s.Init);
P.separator = none;
P.Token(noPos, token.SEMICOLON);
}
P.separator = blank;
P.Stmt(s.Assign);
P.separator = blank;
P.Stmt(s.Body);
}
func (P *Printer) DoCommClause(s *ast.CommClause) {
if s.Rhs != nil {
P.Token(s.Pos(), token.CASE);
P.separator = blank;
if s.Lhs != nil {
P.Expr(s.Lhs);
P.separator = blank;
P.Token(noPos, s.Tok);
P.separator = blank;
}
P.Expr(s.Rhs);
} else {
P.Token(s.Pos(), token.DEFAULT);
}
P.Token(s.Colon, token.COLON);
P.indentation++;
P.StatementList(s.Body);
P.indentation--;
P.newlines = 1;
}
func (P *Printer) DoSelectStmt(s *ast.SelectStmt) {
P.Token(s.Pos(), token.SELECT);
P.separator = blank;
P.Stmt(s.Body);
}
func (P *Printer) DoForStmt(s *ast.ForStmt) {
P.Token(s.Pos(), token.FOR);
P.ControlClause(true, s.Init, s.Cond, s.Post);
P.Stmt(s.Body);
}
func (P *Printer) DoRangeStmt(s *ast.RangeStmt) {
P.Token(s.Pos(), token.FOR);
P.separator = blank;
P.Expr(s.Key);
if s.Value != nil {
P.Token(noPos, token.COMMA);
P.separator = blank;
P.state = inside_list;
P.Expr(s.Value);
}
P.separator = blank;
P.Token(s.TokPos, s.Tok);
P.separator = blank;
P.Token(noPos, token.RANGE);
P.separator = blank;
P.Expr(s.X);
P.separator = blank;
P.Stmt(s.Body);
}
// ----------------------------------------------------------------------------
// Declarations
func (P *Printer) DoBadDecl(d *ast.BadDecl) {
P.String(d.Pos(), "<BAD DECL>");
}
func (P *Printer) importSpec(d *ast.ImportSpec) {
if d.Name != nil {
P.Expr(d.Name);
} else {
P.String(d.Path[0].Pos(), ""); // flush pending ';' separator/newlines
}
P.separator = tab;
// TODO fix for longer package names
P.HtmlPackageName(d.Path[0].Pos(), string(d.Path[0].Value));
P.newlines = 2;
}
func (P *Printer) valueSpec(d *ast.ValueSpec) {
P.Idents(d.Names, P.full);
if d.Type != nil {
P.separator = blank; // TODO switch to tab? (indentation problem with structs)
P.Expr(d.Type);
}
if d.Values != nil {
P.separator = tab;
P.Token(noPos, token.ASSIGN);
P.separator = blank;
P.Exprs(d.Values);
}
P.newlines = 2;
}
func (P *Printer) typeSpec(d *ast.TypeSpec) {
P.Expr(d.Name);
P.separator = blank; // TODO switch to tab? (but indentation problem with structs)
P.Expr(d.Type);
P.newlines = 2;
}
func (P *Printer) spec(d ast.Spec) {
switch s := d.(type) {
case *ast.ImportSpec: P.importSpec(s);
case *ast.ValueSpec: P.valueSpec(s);
case *ast.TypeSpec: P.typeSpec(s);
default: panic("unreachable");
}
}
func (P *Printer) DoGenDecl(d *ast.GenDecl) {
P.Token(d.Pos(), d.Tok);
P.separator = blank;
if d.Lparen.Line > 0 {
// group of parenthesized declarations
P.state = opening_scope;
P.Token(d.Lparen, token.LPAREN);
if len(d.Specs) > 0 {
P.newlines = 1;
for i := 0; i < len(d.Specs); i++ {
if i > 0 {
P.separator = semicolon;
}
P.spec(d.Specs[i]);
P.newlines = 1;
}
}
P.state = closing_scope;
P.Token(d.Rparen, token.RPAREN);
P.opt_semi = true;
P.newlines = 2;
} else {
// single declaration
P.spec(d.Specs[0]);
}
}
func (P *Printer) DoFuncDecl(d *ast.FuncDecl) {
P.Token(d.Pos(), token.FUNC);
P.separator = blank;
if recv := d.Recv; recv != nil {
// method: print receiver
P.Token(noPos, token.LPAREN);
if len(recv.Names) > 0 {
P.Expr(recv.Names[0]);
P.separator = blank;
}
P.Expr(recv.Type);
P.Token(noPos, token.RPAREN);
P.separator = blank;
}
P.Expr(d.Name);
P.Signature(d.Type.Params, d.Type.Results);
if P.full && d.Body != nil {
P.separator = blank;
P.Stmt(d.Body);
}
P.newlines = 3;
}
func (P *Printer) Decl(d ast.Decl) {
d.Visit(P);
}
// ----------------------------------------------------------------------------
// Program
func (P *Printer) DoProgram(p *ast.Program) {
P.full = true;
P.Token(p.Pos(), token.PACKAGE);
P.separator = blank;
P.Expr(p.Name);
P.newlines = 1;
for i := 0; i < len(p.Decls); i++ {
P.Decl(p.Decls[i]);
}
P.newlines = 1;
}
usr/gri/pretty/godoc.go
View file @ a893db87
......@@ -33,6 +33,7 @@ import (
"go/ast";
"go/doc";
"go/parser";
"go/printer";
"go/token";
"http";
"io";
......@@ -47,8 +48,6 @@ import (
"tabwriter";
"template";
"time";
"astprinter"; // TODO remove eventually in favor of ast.Fprint
)
......@@ -90,7 +89,6 @@ var (
// layout control
tabwidth = flag.Int("tabwidth", 4, "tab width");
usetabs = flag.Bool("tabs", false, "align with tabs instead of spaces");
html = flag.Bool("html", false, "print HTML in command-line mode");
// server control
......@@ -129,11 +127,7 @@ func isPkgDir(dir *os.Dir) bool {
func makeTabwriter(writer io.Writer) *tabwriter.Writer {
padchar := byte(' ');
if *usetabs {
padchar = '\t';
}
return tabwriter.NewWriter(writer, *tabwidth, 1, padchar, tabwriter.FilterHTML);
return tabwriter.NewWriter(writer, *tabwidth, 1, byte(' '), 0);
}
......@@ -203,22 +197,12 @@ func parse(path string, mode uint) (*ast.Program, *parseErrors) {
// ----------------------------------------------------------------------------
// Templates
// Return text for decl.
func DeclText(d ast.Decl) []byte {
var buf io.ByteBuffer;
var p astPrinter.Printer;
p.Init(&buf, nil, nil, false);
d.Visit(&p);
return buf.Data();
}
// Return text for expr.
func ExprText(d ast.Expr) []byte {
// Return text for an AST node.
func nodeText(node interface{}, mode uint) []byte {
var buf io.ByteBuffer;
var p astPrinter.Printer;
p.Init(&buf, nil, nil, false);
d.Visit(&p);
tw := makeTabwriter(&buf);
printer.Fprint(tw, node, mode);
tw.Flush();
return buf.Data();
}
......@@ -235,9 +219,9 @@ func toText(x interface{}) []byte {
case String:
return io.StringBytes(v.String());
case ast.Decl:
return DeclText(v);
return nodeText(v, printer.ExportsOnly);
case ast.Expr:
return ExprText(v);
return nodeText(v, printer.ExportsOnly);
}
var buf io.ByteBuffer;
fmt.Fprint(&buf, x);
......@@ -247,23 +231,7 @@ func toText(x interface{}) []byte {
// Template formatter for "html" format.
func htmlFmt(w io.Writer, x interface{}, format string) {
// Can do better than text in some cases.
switch v := x.(type) {
case ast.Decl:
var p astPrinter.Printer;
tw := makeTabwriter(w);
p.Init(tw, nil, nil, true);
v.Visit(&p);
tw.Flush();
case ast.Expr:
var p astPrinter.Printer;
tw := makeTabwriter(w);
p.Init(tw, nil, nil, true);
v.Visit(&p);
tw.Flush();
default:
template.HtmlEscape(w, toText(x));
}
}
......@@ -363,11 +331,7 @@ func serveGoSource(c *http.Conn, name string) {
var buf io.ByteBuffer;
fmt.Fprintln(&buf, "<pre>");
var p astPrinter.Printer;
writer := makeTabwriter(&buf); // for nicely formatted output
p.Init(writer, nil, nil, true);
p.DoProgram(prog);
writer.Flush(); // ignore errors
template.HtmlEscape(&buf, nodeText(prog, printer.DocComments));
fmt.Fprintln(&buf, "</pre>");
servePage(c, name + " - Go source", buf.Data());
......
usr/gri/pretty/pretty.go → usr/gri/pretty/gofmt.go
View file @ a893db87
......@@ -5,12 +5,10 @@
package main
import (
"astprinter"; // TODO remove once go/printer is fully functional
"flag";
"fmt";
"go/ast";
"go/parser";
"go/token";
"go/printer";
"io";
"os";
"sort";
......@@ -20,32 +18,49 @@ import (
var (
// operation modes
columns bool;
// TODO remove silent flag eventually, can achieve same by proving no format file
silent = flag.Bool("s", false, "silent mode: no pretty print output");
silent = flag.Bool("s", false, "silent mode: parsing only");
verbose = flag.Bool("v", false, "verbose mode: trace parsing");
exports = flag.Bool("x", false, "show exports only");
// layout control
format = flag.String("format", "", "format file");
tabwidth = flag.Int("tabwidth", 4, "tab width");
usetabs = flag.Bool("tabs", false, "align with tabs instead of blanks");
optcommas = flag.Bool("optcommas", false, "print optional commas");
optsemis = flag.Bool("optsemis", false, "print optional semicolons");
)
func init() {
user, err := os.Getenv("USER");
flag.BoolVar(&columns, "columns", user == "gri", "print column no. in error messages");
}
func usage() {
fmt.Fprintf(os.Stderr, "usage: pretty { flags } { files }\n");
fmt.Fprintf(os.Stderr, "usage: gofmt [flags] [file.go]\n");
flag.PrintDefaults();
os.Exit(1);
}
// TODO(gri) move this function into tabwriter.go? (also used in godoc)
func parserMode() uint {
mode := parser.ParseComments;
if *verbose {
mode |= parser.Trace;
}
return mode;
}
func printerMode() uint {
mode := uint(0);
if *exports {
mode |= printer.ExportsOnly;
}
if *optcommas {
mode |= printer.OptCommas;
}
if *optsemis {
mode |= printer.OptSemis;
}
return mode;
}
func makeTabwriter(writer io.Writer) *tabwriter.Writer {
padchar := byte(' ');
if *usetabs {
......@@ -56,38 +71,22 @@ func makeTabwriter(writer io.Writer) *tabwriter.Writer {
func main() {
// handle flags
flag.Parse();
if flag.NFlag() == 0 && flag.NArg() == 0 {
usage();
}
// initialize astFormat
astFormat, err := ast.NewFormat(*format);
if *format != "" && err != nil { // ignore error if no format file given
fmt.Fprintf(os.Stderr, "ast.NewFormat(%s): %v\n", *format, err);
os.Exit(1);
}
// determine parsing mode
mode := parser.ParseComments;
if *verbose {
mode |= parser.Trace;
var filename string;
switch flag.NArg() {
case 0: filename = "/dev/stdin";
case 1: filename = flag.Arg(0);
default: usage();
}
// process files
exitcode := 0;
for i := 0; i < flag.NArg(); i++ {
filename := flag.Arg(i);
src, err := io.ReadFile(filename);
if err != nil {
fmt.Fprintf(os.Stderr, "%s: %v\n", filename, err);
exitcode = 1;
continue; // proceed with next file
os.Exit(1);
}
prog, err := parser.Parse(src, mode);
prog, err := parser.Parse(src, parserMode());
if err != nil {
if errors, ok := err.(parser.ErrorList); ok {
sort.Sort(errors);
......@@ -97,27 +96,12 @@ func main() {
} else {
fmt.Fprintf(os.Stderr, "%s: %v\n", filename, err);
}
exitcode = 1;
continue; // proceed with next file
os.Exit(1);
}
if !*silent {
tw := makeTabwriter(os.Stdout);
if *format != "" {
_, err := astFormat.Fprint(tw, prog);
if err != nil {
fmt.Fprintf(os.Stderr, "format error: %v\n", err);
exitcode = 1;
continue; // proceed with next file
}
} else {
var p astPrinter.Printer;
p.Init(tw, nil, nil /*prog.Comments*/, false);
p.DoProgram(prog);
}
tw.Flush();
w := makeTabwriter(os.Stdout);
printer.Fprint(w, prog, printerMode());
w.Flush();
}
}
os.Exit(exitcode);
}
usr/gri/pretty/test.sh
View file @ a893db87
......@@ -10,7 +10,7 @@ if [ -z "$O" ]; then
exit 1
fi
CMD="./pretty -format=ast.txt"
CMD="./gofmt"
TMP1=test_tmp1.go
TMP2=test_tmp2.go
TMP3=test_tmp3.go
......@@ -34,7 +34,7 @@ apply1() {
# the following have semantic errors: bug039.go | bug040.go
test_errors.go | calc.go | method1.go | selftest1.go | func3.go | const2.go | \
bug014.go | bug025.go | bug029.go | bug032.go | bug039.go | bug040.go | bug050.go | bug068.go | \
bug088.go | bug083.go | bug106.go | bug121.go | bug125.go | bug126.go | bug132.go | bug133.go | bug134.go ) ;;
bug088.go | bug083.go | bug106.go | bug121.go | bug125.go | bug126.go | bug132.go | bug133.go | bug134.go | bug160.go ) ;;
* ) $1 $2; count $F;;
esac
}
......
usr/gri/pretty/untab.go deleted 100644 → 0
View file @ c2faeac8
// 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 (
"flag";
"fmt";
"io";
"os";
"tabwriter";
)
var (
tabwidth = flag.Int("tabwidth", 4, "tab width");
usetabs = flag.Bool("usetabs", false, "align with tabs instead of blanks");
)
func error(format string, params ...) {
fmt.Printf(format, params);
os.Exit(1);
}
func untab(name string, src *os.File, dst *tabwriter.Writer) {
n, err := io.Copy(src, dst);
if err != nil {
error("error while processing %s (%v)", name, err);
}
//dst.Flush();
}
func main() {
flag.Parse();
padchar := byte(' ');
if *usetabs {
padchar = '\t';
}
dst := tabwriter.NewWriter(os.Stdout, *tabwidth, 1, padchar, 0);
if flag.NArg() > 0 {
for i := 0; i < flag.NArg(); i++ {
name := flag.Arg(i);
src, err := os.Open(name, os.O_RDONLY, 0);
if err != nil {
error("could not open %s (%v)\n", name, err);
}
untab(name, src, dst);
src.Close(); // ignore errors
}
} else {
// no files => use stdin
untab("/dev/stdin", os.Stdin, dst);
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7