qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-23 06:10:05 -07:00
Code Releases Activity
e4a61c6524
go/usr/gri/pretty/printer.go
Robert Griesemer bf855f5a94 - allow for embeded types in fields, and parameter lists w/o parameter names 
- temporary work-around for 6g bug

R=r
OCL=16052
CL=16052
2008-09-27 17:42:18 -07:00

517 lines
8.2 KiB
Go
Raw Blame History

// 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 Printer
import Scanner "scanner"
import AST "ast"
// Printer implements AST.Visitor
type Printer struct {
indent int;
prec int; // operator precedence
}
func (P *Printer) NewLine(delta int) {
P.indent += delta;
if P.indent < 0 {
panic("negative indent");
}
print("\n");
for i := P.indent; i > 0; i-- {
print("\t");
}
}
func (P *Printer) String(s string) {
print(s);
}
func (P *Printer) Print(x AST.Node) {
outer := P.prec;
P.prec = 0;
x.Visit(P);
P.prec = outer;
}
func (P *Printer) PrintList(p *AST.List) {
for i := 0; i < p.len(); i++ {
if i > 0 {
P.String(", ");
}
P.Print(p.at(i));
}
}
// ----------------------------------------------------------------------------
// Basics
func (P *Printer) DoNil(x *AST.Nil) {
P.String("<NIL>");
}
func (P *Printer) DoIdent(x *AST.Ident) {
P.String(x.val);
}
// ----------------------------------------------------------------------------
// Types
func (P *Printer) DoFunctionType(x *AST.FunctionType) {
P.String("(");
P.PrintList(x.params);
P.String(")");
}
func (P *Printer) DoArrayType(x *AST.ArrayType) {
P.String("[");
P.Print(x.len_);
P.String("] ");
P.Print(x.elt);
}
func (P *Printer) DoStructType(x *AST.StructType) {
P.String("struct {");
if x.fields.len() > 0 {
P.NewLine(1);
for i := 0; i < x.fields.len(); i++ {
if i > 0 {
P.NewLine(0);
}
P.Print(x.fields.at(i));
P.String(";");
}
P.NewLine(-1);
}
P.String("}");
}
func (P *Printer) DoMapType(x *AST.MapType) {
P.String("[");
P.Print(x.key);
P.String("] ");
P.Print(x.val);
}
func (P *Printer) DoChannelType(x *AST.ChannelType) {
switch x.mode {
case AST.FULL: P.String("chan ");
case AST.RECV: P.String("<-chan ");
case AST.SEND: P.String("chan <- ");
}
P.Print(x.elt);
}
func (P *Printer) DoInterfaceType(x *AST.InterfaceType) {
P.String("interface {");
if x.methods.len() > 0 {
P.NewLine(1);
for i := 0; i < x.methods.len(); i++ {
if i > 0 {
P.NewLine(0);
}
P.Print(x.methods.at(i));
P.String(";");
}
P.NewLine(-1);
}
P.String("}");
}
func (P *Printer) DoPointerType(x *AST.PointerType) {
P.String("*");
P.Print(x.base);
}
// ----------------------------------------------------------------------------
// Declarations
func (P *Printer) DoBlock(x *AST.Block);
func (P *Printer) DoImportDecl(x *AST.ImportDecl) {
if x.ident != nil {
P.Print(x.ident);
P.String(" ");
}
P.String(x.file);
}
func (P *Printer) DoConstDecl(x *AST.ConstDecl) {
P.Print(x.ident);
P.String(" ");
P.Print(x.typ);
P.String(" = ");
P.Print(x.val);
}
func (P *Printer) DoTypeDecl(x *AST.TypeDecl) {
P.Print(x.ident);
P.String(" ");
P.Print(x.typ);
}
func (P *Printer) DoVarDecl(x *AST.VarDecl) {
P.PrintList(x.idents);
P.String(" ");
P.Print(x.typ);
if x.vals != nil {
P.String(" = ");
P.PrintList(x.vals);
}
}
func (P *Printer) DoVarDeclList(x *AST.VarDeclList) {
if x.idents != nil {
P.PrintList(x.idents);
P.String(" ");
}
P.Print(x.typ);
}
func (P *Printer) DoFuncDecl(x *AST.FuncDecl) {
P.String("func ");
if x.typ.recv != nil {
P.String("(");
P.DoVarDeclList(x.typ.recv);
P.String(") ");
}
P.DoIdent(x.ident);
P.DoFunctionType(x.typ);
P.String(" ");
if x.body != nil {
P.DoBlock(x.body);
} else {
P.String(";");
}
P.NewLine(0);
P.NewLine(0);
P.NewLine(0);
}
func (P *Printer) DoMethodDecl(x *AST.MethodDecl) {
P.DoIdent(x.ident);
P.DoFunctionType(x.typ);
}
func (P *Printer) DoDeclaration(x *AST.Declaration) {
P.String(Scanner.TokenName(x.tok));
P.String(" ");
switch x.decls.len() {
case 0:
P.String("()");
case 1:
P.Print(x.decls.at(0));
default:
P.String("(");
P.NewLine(1);
for i := 0; i < x.decls.len(); i++ {
if i > 0 {
P.NewLine(0);
}
P.Print(x.decls.at(i));
P.String(";");
}
P.NewLine(-1);
P.String(")");
}
P.NewLine(0);
}
// ----------------------------------------------------------------------------
// Expressions
func (P *Printer) DoBinary(x *AST.Binary) {
outer := P.prec;
P.prec = Scanner.Precedence(x.tok);
if P.prec < outer {
print("(");
}
P.Print(x.x);
P.String(" " + Scanner.TokenName(x.tok) + " ");
P.Print(x.y);
if P.prec < outer {
print(")");
}
P.prec = outer;
}
func (P *Printer) DoUnary(x *AST.Unary) {
P.String(Scanner.TokenName(x.tok));
P.Print(x.x);
}
func (P *Printer) DoLiteral(x *AST.Literal) {
P.String(x.val);
}
func (P *Printer) DoPair(x *AST.Pair) {
P.Print(x.x);
P.String(" : ");
P.Print(x.y);
}
func (P *Printer) DoIndex(x *AST.Index) {
P.Print(x.x);
P.String("[");
P.Print(x.index);
P.String("]");
}
func (P *Printer) DoCall(x *AST.Call) {
P.Print(x.fun);
P.String("(");
P.PrintList(x.args);
P.String(")");
}
func (P *Printer) DoSelector(x *AST.Selector) {
P.Print(x.x);
P.String(".");
P.String(x.field);
}
func (P *Printer) DoCompositeLit(x *AST.CompositeLit) {
P.Print(x.typ);
P.String("{");
P.PrintList(x.vals);
P.String("}");
}
func (P *Printer) DoFunctionLit(x *AST.FunctionLit) {
P.String("func ");
P.Print(x.typ);
P.String(" ");
P.Print(x.body);
}
// ----------------------------------------------------------------------------
// Statements
func (P *Printer) DoBlock(x *AST.Block) {
P.String("{");
if x.stats != nil {
P.NewLine(1);
for i := 0; i < x.stats.len(); i++ {
if i > 0 {
P.NewLine(0);
}
P.Print(x.stats.at(i));
}
P.NewLine(-1);
}
P.String("}");
}
func (P *Printer) DoLabel(x *AST.Label) {
P.NewLine(-1);
P.Print(x.ident);
P.String(":");
P.indent++;
}
func (P *Printer) DoExprStat(x *AST.ExprStat) {
P.Print(x.expr);
//P.String(";");
}
func (P *Printer) DoAssignment(x *AST.Assignment) {
P.PrintList(x.lhs);
P.String(" " + Scanner.TokenName(x.tok) + " ");
P.PrintList(x.rhs);
//P.String(";");
}
func (P *Printer) PrintControlClause(x *AST.ControlClause) {
if x.has_init {
P.String(" ");
P.Print(x.init);
P.String(";");
}
if x.has_expr {
P.String(" ");
P.Print(x.expr);
}
if x.has_post {
P.String("; ");
P.Print(x.post);
}
P.String(" ");
}
func (P *Printer) DoIfStat(x *AST.IfStat) {
P.String("if");
P.PrintControlClause(x.ctrl);
P.DoBlock(x.then);
if x.has_else {
P.String(" else ");
P.Print(x.else_);
}
}
func (P *Printer) DoForStat(x *AST.ForStat) {
P.String("for");
P.PrintControlClause(x.ctrl);
P.DoBlock(x.body);
}
/*
func AnalyzeCase(x *AST.SwitchStat) bool {
for i := 0; i < x.cases.len(); i++ {
clause := x.cases.at(i).(AST.CaseClause);
if clause.stats.len() > 1 {
return false;
}
}
return true;
}
*/
func (P *Printer) DoCaseClause(x *AST.CaseClause) {
if x.exprs != nil {
P.String("case ");
P.PrintList(x.exprs);
P.String(":");
} else {
P.String("default:");
}
n := x.stats.len();
m := n;
if x.falls {
m++;
}
if m == 0 {
P.NewLine(0);
} else {
P.NewLine(1);
for i := 0; i < n; i++ {
if i > 0 {
P.NewLine(0);
}
P.Print(x.stats.at(i));
}
if x.falls {
if n > 0 {
P.NewLine(0);
}
P.String("fallthrough;");
}
P.NewLine(-1);
}
}
func (P *Printer) DoSwitchStat(x *AST.SwitchStat) {
P.String("switch");
P.PrintControlClause(x.ctrl);
P.String("{");
P.NewLine(0);
for i := 0; i < x.cases.len(); i++ {
P.Print(x.cases.at(i));
}
P.NewLine(0);
P.String("}");
}
func (P *Printer) DoReturnStat(x *AST.ReturnStat) {
P.String("return ");
P.PrintList(x.res);
P.String(";");
}
func (P *Printer) DoIncDecStat(x *AST.IncDecStat) {
P.Print(x.expr);
P.String(Scanner.TokenName(x.tok));
//P.String(";");
}
func (P *Printer) DoControlFlowStat(x *AST.ControlFlowStat) {
P.String(Scanner.TokenName(x.tok));
if x.label != nil {
P.String(" ");
P.Print(x.label);
}
P.String(";");
}
func (P *Printer) DoGoStat(x *AST.GoStat) {
P.String("go ");
P.Print(x.expr);
P.String(";");
}
// ----------------------------------------------------------------------------
// Program
func (P *Printer) DoProgram(x *AST.Program) {
P.String("package ");
P.DoIdent(x.ident);
P.NewLine(0);
for i := 0; i < x.decls.len(); i++ {
P.Print(x.decls.at(i));
}
}
// ----------------------------------------------------------------------------
// Driver
export func Print(x AST.Node) {
var P Printer;
(&P).Print(x);
print("\n");
}
View Git Blame Copy Permalink