mirror of
https://github.com/golang/go
synced 2024-10-03 22:21:22 -06:00
82fbbdfc7d
- fixed expression and statement printing - missing: declarations, comments R=r OCL=17207 CL=17207
431 lines
7.5 KiB
Go
431 lines
7.5 KiB
Go
// 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 Node "node"
|
|
|
|
|
|
export type Printer struct {
|
|
level int; // true scope level
|
|
indent int; // indentation level
|
|
semi bool; // pending ";"
|
|
newl bool; // pending "\n"
|
|
}
|
|
|
|
|
|
func (P *Printer) String(s string) {
|
|
if P.semi && P.level > 0 { // no semicolons at level 0
|
|
print(";");
|
|
}
|
|
if P.newl {
|
|
print("\n");
|
|
for i := P.indent; i > 0; i-- {
|
|
print("\t");
|
|
}
|
|
}
|
|
print(s);
|
|
P.newl, P.semi = false, false;
|
|
}
|
|
|
|
|
|
func (P *Printer) Token(tok int) {
|
|
P.String(Scanner.TokenString(tok));
|
|
}
|
|
|
|
|
|
func (P *Printer) NewLine() { // explicit "\n"
|
|
print("\n");
|
|
P.semi, P.newl = false, true;
|
|
}
|
|
|
|
|
|
func (P *Printer) OpenScope(paren string) {
|
|
P.semi, P.newl = false, false;
|
|
P.String(paren);
|
|
P.level++;
|
|
P.indent++;
|
|
P.newl = true;
|
|
}
|
|
|
|
|
|
func (P *Printer) CloseScope(paren string) {
|
|
P.indent--;
|
|
P.semi = false;
|
|
P.String(paren);
|
|
P.level--;
|
|
P.semi, P.newl = false, true;
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Types
|
|
|
|
func (P *Printer) Expr(x *Node.Expr)
|
|
|
|
func (P *Printer) Type(t *Node.Type) {
|
|
switch t.tok {
|
|
case Scanner.IDENT:
|
|
P.Expr(t.expr);
|
|
|
|
case Scanner.LBRACK:
|
|
P.String("[");
|
|
if t.expr != nil {
|
|
P.Expr(t.expr);
|
|
}
|
|
P.String("] ");
|
|
P.Type(t.elt);
|
|
|
|
case Scanner.STRUCT:
|
|
P.String("struct");
|
|
if t.list != nil {
|
|
P.OpenScope(" {");
|
|
/*
|
|
for i := 0; i < x.fields.len(); i++ {
|
|
P.Print(x.fields.at(i));
|
|
P.newl, P.semi = true, true;
|
|
}
|
|
*/
|
|
P.CloseScope("}");
|
|
}
|
|
|
|
case Scanner.MAP:
|
|
P.String("[");
|
|
P.Type(t.key);
|
|
P.String("] ");
|
|
P.Type(t.elt);
|
|
|
|
case Scanner.CHAN:
|
|
switch t.mode {
|
|
case Node.FULL: P.String("chan ");
|
|
case Node.RECV: P.String("<-chan ");
|
|
case Node.SEND: P.String("chan <- ");
|
|
}
|
|
P.Type(t.elt);
|
|
|
|
case Scanner.INTERFACE:
|
|
P.String("interface");
|
|
if t.list != nil {
|
|
P.OpenScope(" {");
|
|
/*
|
|
for i := 0; i < x.methods.len(); i++ {
|
|
P.Print(x.methods.at(i));
|
|
P.newl, P.semi = true, true;
|
|
}
|
|
*/
|
|
P.CloseScope("}");
|
|
}
|
|
|
|
case Scanner.MUL:
|
|
P.String("*");
|
|
P.Type(t.elt);
|
|
|
|
case Scanner.LPAREN:
|
|
P.String("(");
|
|
//P.PrintList(x.params);
|
|
P.String(")");
|
|
/*
|
|
if x.result != nil {
|
|
P.String(" (");
|
|
P.PrintList(x.result);
|
|
P.String(")");
|
|
}
|
|
*/
|
|
|
|
default:
|
|
panic("UNREACHABLE");
|
|
}
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Expressions
|
|
|
|
func (P *Printer) Expr1(x *Node.Expr, prec1 int) {
|
|
if x == nil {
|
|
return; // empty expression list
|
|
}
|
|
|
|
switch x.tok {
|
|
case Scanner.IDENT, Scanner.INT, Scanner.STRING, Scanner.FLOAT:
|
|
P.String(x.s);
|
|
|
|
case Scanner.COMMA:
|
|
P.Expr1(x.x, 0);
|
|
P.String(", ");
|
|
P.Expr1(x.y, 0);
|
|
|
|
case Scanner.PERIOD:
|
|
P.Expr1(x.x, 8);
|
|
P.String(".");
|
|
P.Expr1(x.y, 8);
|
|
|
|
case Scanner.LBRACK:
|
|
P.Expr1(x.x, 8);
|
|
P.String("[");
|
|
P.Expr1(x.y, 0);
|
|
P.String("]");
|
|
|
|
case Scanner.LPAREN:
|
|
P.Expr1(x.x, 8);
|
|
P.String("(");
|
|
P.Expr1(x.y, 0);
|
|
P.String(")");
|
|
|
|
default:
|
|
if x.x == nil {
|
|
// unary expression
|
|
P.Token(x.tok);
|
|
P.Expr1(x.y, 7);
|
|
} else {
|
|
// binary expression: print ()'s if necessary
|
|
prec := Scanner.Precedence(x.tok);
|
|
if prec < prec1 {
|
|
print("(");
|
|
}
|
|
P.Expr1(x.x, prec);
|
|
P.String(" ");
|
|
P.Token(x.tok);
|
|
P.String(" ");
|
|
P.Expr1(x.y, prec);
|
|
if prec < prec1 {
|
|
print(")");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
func (P *Printer) Expr(x *Node.Expr) {
|
|
P.Expr1(x, 0);
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Statements
|
|
|
|
func (P *Printer) Stat(s *Node.Stat)
|
|
|
|
func (P *Printer) StatementList(list *Node.List) {
|
|
for i, n := 0, list.len(); i < n; i++ {
|
|
P.Stat(list.at(i).(*Node.Stat));
|
|
P.newl = true;
|
|
}
|
|
}
|
|
|
|
|
|
func (P *Printer) Block(list *Node.List, indent bool) {
|
|
P.OpenScope("{");
|
|
if !indent {
|
|
P.indent--;
|
|
}
|
|
P.StatementList(list);
|
|
if !indent {
|
|
P.indent++;
|
|
}
|
|
P.CloseScope("}");
|
|
}
|
|
|
|
|
|
func (P *Printer) ControlClause(s *Node.Stat) {
|
|
if s.init != nil {
|
|
P.String(" ");
|
|
P.Stat(s.init);
|
|
P.semi = true;
|
|
P.String("");
|
|
}
|
|
if s.expr != nil {
|
|
P.String(" ");
|
|
P.Expr(s.expr);
|
|
P.semi = false;
|
|
}
|
|
if s.tok == Scanner.FOR && s.post != nil {
|
|
P.semi = true;
|
|
P.String(" ");
|
|
P.Stat(s.post);
|
|
P.semi = false;
|
|
}
|
|
P.String(" ");
|
|
}
|
|
|
|
|
|
func (P *Printer) Declaration(d *Node.Decl);
|
|
|
|
func (P *Printer) Stat(s *Node.Stat) {
|
|
if s == nil { // TODO remove this check
|
|
P.String("<nil stat>");
|
|
return;
|
|
}
|
|
|
|
switch s.tok {
|
|
case 0: // TODO use a real token const
|
|
P.Expr(s.expr);
|
|
P.semi = true;
|
|
|
|
case Scanner.CONST, Scanner.TYPE, Scanner.VAR:
|
|
P.Declaration(s.decl);
|
|
|
|
case Scanner.DEFINE, Scanner.ASSIGN, Scanner.ADD_ASSIGN,
|
|
Scanner.SUB_ASSIGN, Scanner.MUL_ASSIGN, Scanner.QUO_ASSIGN,
|
|
Scanner.REM_ASSIGN, Scanner.AND_ASSIGN, Scanner.OR_ASSIGN,
|
|
Scanner.XOR_ASSIGN, Scanner.SHL_ASSIGN, Scanner.SHR_ASSIGN:
|
|
P.Expr(s.lhs);
|
|
P.String(" ");
|
|
P.Token(s.tok);
|
|
P.String(" ");
|
|
P.Expr(s.expr);
|
|
P.semi = true;
|
|
|
|
case Scanner.INC, Scanner.DEC:
|
|
P.Expr(s.expr);
|
|
P.Token(s.tok);
|
|
P.semi = true;
|
|
|
|
case Scanner.LBRACE:
|
|
P.Block(s.block, true);
|
|
|
|
case Scanner.IF:
|
|
P.String("if");
|
|
P.ControlClause(s);
|
|
P.Block(s.block, true);
|
|
if s.post != nil {
|
|
P.newl = false;
|
|
P.String(" else ");
|
|
P.Stat(s.post);
|
|
}
|
|
|
|
case Scanner.FOR:
|
|
P.String("for");
|
|
P.ControlClause(s);
|
|
P.Block(s.block, true);
|
|
|
|
case Scanner.SWITCH, Scanner.SELECT:
|
|
P.Token(s.tok);
|
|
P.ControlClause(s);
|
|
P.Block(s.block, false);
|
|
|
|
case Scanner.CASE, Scanner.DEFAULT:
|
|
P.Token(s.tok);
|
|
if s.expr != nil {
|
|
P.String(" ");
|
|
P.Expr(s.expr);
|
|
}
|
|
P.String(":");
|
|
P.OpenScope("");
|
|
P.StatementList(s.block);
|
|
P.CloseScope("");
|
|
|
|
case Scanner.GO, Scanner.RETURN, Scanner.BREAK, Scanner.CONTINUE, Scanner.GOTO:
|
|
P.Token(s.tok);
|
|
P.String(" ");
|
|
P.Expr(s.expr);
|
|
P.semi = true;
|
|
|
|
default:
|
|
P.String("<stat>");
|
|
P.semi = true;
|
|
}
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Declarations
|
|
|
|
|
|
/*
|
|
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);
|
|
if x.body != nil {
|
|
P.String(" ");
|
|
P.DoBlock(x.body);
|
|
} else {
|
|
P.String(" ;");
|
|
}
|
|
P.NewLine();
|
|
P.NewLine();
|
|
|
|
}
|
|
|
|
|
|
func (P *Printer) DoMethodDecl(x *AST.MethodDecl) {
|
|
//P.DoIdent(x.ident);
|
|
//P.DoFunctionType(x.typ);
|
|
}
|
|
*/
|
|
|
|
|
|
func (P *Printer) Declaration(d *Node.Decl) {
|
|
if d.tok == Scanner.FUNC || d.ident == nil {
|
|
if d.exported {
|
|
P.String("export ");
|
|
}
|
|
P.Token(d.tok);
|
|
P.String(" ");
|
|
}
|
|
|
|
if d.ident == nil {
|
|
switch d.list.len() {
|
|
case 0:
|
|
P.String("()");
|
|
case 1:
|
|
P.Declaration(d.list.at(0).(*Node.Decl));
|
|
default:
|
|
P.OpenScope("(");
|
|
for i := 0; i < d.list.len(); i++ {
|
|
P.Declaration(d.list.at(i).(*Node.Decl));
|
|
P.newl, P.semi = true, true;
|
|
}
|
|
P.CloseScope(")");
|
|
}
|
|
|
|
} else {
|
|
P.Expr(d.ident);
|
|
if d.typ != nil {
|
|
P.String(" ");
|
|
P.Type(d.typ);
|
|
}
|
|
if d.val != nil {
|
|
P.String(" = ");
|
|
P.Expr(d.val);
|
|
}
|
|
if d.list != nil {
|
|
if d.tok != Scanner.FUNC {
|
|
panic("must be a func declaration");
|
|
}
|
|
P.String(" ");
|
|
P.Block(d.list, true);
|
|
}
|
|
}
|
|
|
|
// extra newline at the top level
|
|
if P.level == 0 {
|
|
P.NewLine();
|
|
}
|
|
|
|
P.newl = true;
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Program
|
|
|
|
func (P *Printer) Program(p *Node.Program) {
|
|
P.String("package ");
|
|
P.Expr(p.ident);
|
|
P.NewLine();
|
|
for i := 0; i < p.decls.len(); i++ {
|
|
P.Declaration(p.decls.at(i));
|
|
}
|
|
P.newl = true;
|
|
P.String("");
|
|
}
|