Commit 7c3a2c47 authored by Robert Griesemer's avatar Robert Griesemer

- snapshot of pretty printer work

- accepts all Go code (use -s flag)
- complete rewrite of AST, AST building, and printing
  (as a result much more compact)
- printing severely screwed up at the moment, but should be
  fully working in 1 more day

R=r
DELTA=2118  (514 added, 980 deleted, 624 changed)
OCL=17161
CL=17161
parent 0b05e91f
...@@ -54,7 +54,11 @@ clean: ...@@ -54,7 +54,11 @@ clean:
pretty.6: parser.6 printer.6 platform.6 scanner.6 pretty.6: parser.6 printer.6 platform.6 scanner.6
parser.6: ast.6 scanner.6 utils.6 printer.6 printer.6: node.6 scanner.6
parser.6: scanner.6 utils.6 printer.6 node.6
node.6: scanner.6
scanner.6: utils.6 platform.6 scanner.6: utils.6 platform.6
......
This diff is collapsed.
// 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 Node
import Scanner "scanner"
type Node interface {}
type (
Type struct;
Expr struct;
Stat struct;
Decl struct;
)
// ----------------------------------------------------------------------------
// Lists
//
// If p is a list and p == nil, then p.len() == 0.
// Thus, empty lists can be represented by nil.
export type List struct {
a *[] Node;
}
func (p *List) len() int {
if p == nil { return 0; }
return len(p.a);
}
func (p *List) at(i int) Node {
return p.a[i];
}
func (p *List) Add (x Node) {
a := p.a;
n := len(a);
if n == cap(a) {
b := new([] Node, 2*n);
for i := 0; i < n; i++ {
b[i] = a[i];
}
a = b;
}
a = a[0 : n + 1];
a[n] = x;
p.a = a;
}
/*
func (p *List) Print() {
print("(");
for i, n := 0, p.len(); i < n; i++ {
if i > 0 {
print(", ");
}
p.at(i).Print();
}
print(")");
}
*/
export func NewList() *List {
p := new(List);
p.a = new([] Node, 10) [0 : 0];
return p;
}
// ----------------------------------------------------------------------------
// Types
export const /* channel mode */ (
FULL = iota;
SEND;
RECV;
)
export type Type struct {
pos, tok int;
expr *Expr; // type name, array length
mode int; // channel mode
key *Type; // map key
elt *Type; // array element, map or channel value, or pointer base type
list *List; // struct fields, interface methods, function parameters
}
export func NewType(pos, tok int) *Type {
t := new(Type);
t.pos, t.tok = pos, tok;
return t;
}
// ----------------------------------------------------------------------------
// Expressions
//
// Expression pairs are represented as binary expressions with operator ":"
// Expression lists are represented as binary expressions with operator ","
export type Val struct {
i int;
f float;
s string;
t *Type;
}
export type Expr struct {
pos, tok int;
x, y *Expr; // binary (x, y) and unary (y) expressions
ident string; // identifiers
val *Val; // literals
}
func (x *Expr) len() int {
if x == nil {
return 0;
}
n := 1;
for ; x.tok == Scanner.COMMA; x = x.y {
n++;
}
return n;
}
/*
func (x *Expr) Print() {
switch {
case x == nil:
print("nil");
case x.val != nil:
print(x.val.s);
default:
if x.x == nil {
print(Scanner.TokenName(x.tok));
} else {
x.x.Print();
print(" ");
print(Scanner.TokenName(x.tok));
print(" ");
}
x.y.Print();
}
}
*/
export func NewExpr(pos, tok int, x, y *Expr) *Expr {
e := new(Expr);
e.pos, e.tok, e.x, e.y = pos, tok, x, y;
return e;
}
export func NewIdent(pos int, ident string) *Expr {
e := new(Expr);
e.pos, e.tok, e.ident = pos, Scanner.IDENT, ident;
return e;
}
export func NewVal(pos, tok int, val *Val) *Expr {
e := new(Expr);
e.pos, e.tok, e.val = pos, tok, val;
return e;
}
// ----------------------------------------------------------------------------
// Statements
export type Stat struct {
pos, tok int;
init *Stat;
expr *Expr;
post *Stat;
block *List;
decl *Decl;
}
export func NewStat(pos, tok int) *Stat {
s := new(Stat);
s.pos, s.tok = pos, tok;
return s;
}
// ----------------------------------------------------------------------------
// Declarations
export type VarDeclList struct {
}
func (d *VarDeclList) Print() {
}
export type Decl struct {
pos, tok int;
exported bool;
ident *Expr; // nil for ()-style declarations
typ *Type;
val *Expr;
// list of *Decl for ()-style declarations
// list of *Stat for func declarations (or nil for forward decl)
list *List;
}
export func NewDecl(pos, tok int, exported bool) *Decl {
d := new(Decl);
d.pos, d.tok, d.exported = pos, tok, exported;
return d;
}
// ----------------------------------------------------------------------------
// Program
export type Program struct {
pos int; // tok is Scanner.PACKAGE
ident *Expr;
decls *List;
}
export func NewProgram(pos int) *Program {
p := new(Program);
p.pos = pos;
return p;
}
This diff is collapsed.
...@@ -7,7 +7,6 @@ package main ...@@ -7,7 +7,6 @@ package main
import Flag "flag" import Flag "flag"
import Platform "platform" import Platform "platform"
import Scanner "scanner" import Scanner "scanner"
import AST "ast" // should not be needed
import Parser "parser" import Parser "parser"
import Printer "printer" import Printer "printer"
...@@ -66,7 +65,8 @@ func main() { ...@@ -66,7 +65,8 @@ func main() {
} }
if !silent.BVal() { if !silent.BVal() {
Printer.Print(prog); var P Printer.Printer;
(&P).Program(prog);
} }
} }
} }
This diff is collapsed.
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