Skip to content

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

- fixed a bug with building right-recursive trees iteratively 

- moving scope handling into parser (simpler)
- snapshot of work today so far

R=r
OCL=22301
CL=22301
parent 7843a14d
Hide whitespace changes
Inline Side-by-side
Showing with 149 additions and 127 deletions
usr/gri/pretty/parser.go
View file @ 4dc3d74a
......@@ -32,11 +32,34 @@ export type Parser struct {
// Nesting levels
expr_lev int; // 0 = control clause level, 1 = expr inside ()'s
scope_lev int; // 0 = global scope, 1 = function scope of global functions, etc.
// Scopes
top_scope *Globals.Scope;
};
// ----------------------------------------------------------------------------
// Support functions
// Elementary support
func unimplemented() {
panic("unimplemented");
}
func unreachable() {
panic("unreachable");
}
func assert(pred bool) {
if !pred {
panic("assertion failed");
}
}
// ----------------------------------------------------------------------------
// Parsing support
func (P *Parser) PrintIndent() {
for i := P.indent; i > 0; i-- {
......@@ -127,6 +150,56 @@ func (P *Parser) OptSemicolon() {
}
// ----------------------------------------------------------------------------
// Scopes
func (P *Parser) OpenScope() {
P.top_scope = Globals.NewScope(P.top_scope);
}
func (P *Parser) CloseScope() {
P.top_scope = P.top_scope.parent;
}
func (P *Parser) Lookup(ident string) *Globals.Object {
for scope := P.top_scope; scope != nil; scope = scope.parent {
obj := scope.Lookup(ident);
if obj != nil {
return obj;
}
}
return nil;
}
func (P *Parser) DeclareInScope(scope *Globals.Scope, x *AST.Expr, kind int) {
if P.scope_lev < 0 {
panic("cannot declare objects in other packages");
}
obj := x.obj;
assert(x.tok == Scanner.IDENT && obj.kind == Object.NONE);
obj.kind = kind;
obj.pnolev = P.scope_lev;
if scope.Lookup(obj.ident) != nil {
P.Error(obj.pos, `"` + obj.ident + `" is declared already`);
return; // don't insert it into the scope
}
scope.Insert(obj);
}
// Declare a comma-separated list of idents or a single ident.
func (P *Parser) Declare(p *AST.Expr, kind int) {
for p.tok == Scanner.COMMA {
P.DeclareInScope(P.top_scope, p.x, kind);
p = p.y;
}
P.DeclareInScope(P.top_scope, p, kind);
}
// ----------------------------------------------------------------------------
// AST support
......@@ -195,16 +268,18 @@ func (P *Parser) ParseIdent() *AST.Expr {
func (P *Parser) ParseIdentList() *AST.Expr {
P.Trace("IdentList");
var last *AST.Expr;
x := P.ParseIdent();
for first := true; P.tok == Scanner.COMMA; {
for P.tok == Scanner.COMMA {
pos := P.pos;
P.Next();
y := P.ParseIdent();
if first {
if last == nil {
x = P.NewExpr(pos, Scanner.COMMA, x, y);
first = false;
last = x;
} else {
x.y = P.NewExpr(pos, Scanner.COMMA, x.y, y);
last.y = P.NewExpr(pos, Scanner.COMMA, last.y, y);
last = last.y;
}
}
......@@ -460,11 +535,17 @@ func (P *Parser) ParseResult() *AST.Type {
func (P *Parser) ParseFunctionType() *AST.Type {
P.Trace("FunctionType");
P.OpenScope();
P.scope_lev++;
t := AST.NewType(P.pos, Scanner.LPAREN);
t.list = P.ParseParameters(true).list; // TODO find better solution
t.end = P.pos;
t.elt = P.ParseResult();
P.scope_lev--;
P.CloseScope();
P.Ecart();
return t;
}
......@@ -493,6 +574,9 @@ func (P *Parser) ParseInterfaceType() *AST.Type {
P.Expect(Scanner.INTERFACE);
if P.tok == Scanner.LBRACE {
P.Next();
P.OpenScope();
P.scope_lev++;
t.list = array.New(0);
for P.tok == Scanner.IDENT {
P.ParseMethodSpec(t.list);
......@@ -501,6 +585,9 @@ func (P *Parser) ParseInterfaceType() *AST.Type {
}
}
t.end = P.pos;
P.scope_lev--;
P.CloseScope();
P.Expect(Scanner.RBRACE);
}
......@@ -533,6 +620,9 @@ func (P *Parser) ParseStructType() *AST.Type {
P.Expect(Scanner.STRUCT);
if P.tok == Scanner.LBRACE {
P.Next();
P.OpenScope();
P.scope_lev++;
t.list = array.New(0);
for P.tok != Scanner.RBRACE && P.tok != Scanner.EOF {
P.ParseVarDeclList(t.list, false);
......@@ -548,6 +638,9 @@ func (P *Parser) ParseStructType() *AST.Type {
}
P.OptSemicolon();
t.end = P.pos;
P.scope_lev--;
P.CloseScope();
P.Expect(Scanner.RBRACE);
}
......@@ -625,8 +718,12 @@ func (P *Parser) ParseBlock() (slist *array.Array, end int) {
P.Trace("Block");
P.Expect(Scanner.LBRACE);
P.OpenScope();
slist = P.ParseStatementList();
end = P.pos;
P.CloseScope();
P.Expect(Scanner.RBRACE);
P.opt_semi = true;
......@@ -832,7 +929,8 @@ func (P *Parser) ParseCompositeElements() *AST.Expr {
singles = false;
}
for first := true; P.tok != Scanner.RBRACE && P.tok != Scanner.EOF; {
var last *AST.Expr;
for P.tok != Scanner.RBRACE && P.tok != Scanner.EOF {
y := P.ParseExpression(0);
if singles {
......@@ -845,10 +943,12 @@ func (P *Parser) ParseCompositeElements() *AST.Expr {
}
}
if first {
if last == nil {
x = P.NewExpr(pos, Scanner.COMMA, x, y);
last = x;
} else {
x.y = P.NewExpr(pos, Scanner.COMMA, x.y, y);
last.y = P.NewExpr(pos, Scanner.COMMA, last.y, y);
last = last.y;
}
if P.tok == Scanner.COMMA {
......@@ -1143,6 +1243,7 @@ func (P *Parser) ParseControlClause(keyword int) *AST.Stat {
func (P *Parser) ParseIfStat() *AST.Stat {
P.Trace("IfStat");
P.OpenScope();
s := P.ParseControlClause(Scanner.IF);
s.block, s.end = P.ParseBlock();
if P.tok == Scanner.ELSE {
......@@ -1169,6 +1270,7 @@ func (P *Parser) ParseIfStat() *AST.Stat {
}
s.post = s1;
}
P.CloseScope();
P.Ecart();
return s;
......@@ -1178,8 +1280,10 @@ func (P *Parser) ParseIfStat() *AST.Stat {
func (P *Parser) ParseForStat() *AST.Stat {
P.Trace("ForStat");
P.OpenScope();
s := P.ParseControlClause(Scanner.FOR);
s.block, s.end = P.ParseBlock();
P.CloseScope();
P.Ecart();
return s;
......@@ -1219,6 +1323,7 @@ func (P *Parser) ParseCaseClause() *AST.Stat {
func (P *Parser) ParseSwitchStat() *AST.Stat {
P.Trace("SwitchStat");
P.OpenScope();
s := P.ParseControlClause(Scanner.SWITCH);
s.block = array.New(0);
P.Expect(Scanner.LBRACE);
......@@ -1228,6 +1333,7 @@ func (P *Parser) ParseSwitchStat() *AST.Stat {
s.end = P.pos;
P.Expect(Scanner.RBRACE);
P.opt_semi = true;
P.CloseScope();
P.Ecart();
return s;
......@@ -1382,6 +1488,10 @@ func (P *Parser) ParseImportSpec(pos int) *AST.Decl {
P.Expect(Scanner.STRING); // use Expect() error handling
}
if d.ident != nil {
P.Declare(d.ident, Object.PACKAGE);
}
P.Ecart();
return d;
}
......@@ -1397,6 +1507,8 @@ func (P *Parser) ParseConstSpec(exported bool, pos int) *AST.Decl {
P.Next();
d.val = P.ParseExpressionList();
}
P.Declare(d.ident, Object.CONST);
P.Ecart();
return d;
......@@ -1432,6 +1544,8 @@ func (P *Parser) ParseVarSpec(exported bool, pos int) *AST.Decl {
}
}
P.Declare(d.ident, Object.VAR);
P.Ecart();
return d;
}
......@@ -1581,24 +1695,29 @@ func (P *Parser) ParseDeclaration() *AST.Decl {
func (P *Parser) ParseProgram() *AST.Program {
P.Trace("Program");
P.OpenScope();
p := AST.NewProgram(P.pos);
P.Expect(Scanner.PACKAGE);
p.ident = P.ParseIdent();
p.decls = array.New(0);
for P.tok == Scanner.IMPORT {
p.decls.Push(P.ParseDecl(false, Scanner.IMPORT));
P.OptSemicolon();
}
if !P.deps {
for P.tok != Scanner.EOF {
p.decls.Push(P.ParseDeclaration());
// package body
{ P.OpenScope();
p.decls = array.New(0);
for P.tok == Scanner.IMPORT {
p.decls.Push(P.ParseDecl(false, Scanner.IMPORT));
P.OptSemicolon();
}
if !P.deps {
for P.tok != Scanner.EOF {
p.decls.Push(P.ParseDeclaration());
P.OptSemicolon();
}
}
P.CloseScope();
}
p.comments = P.comments;
P.CloseScope();
P.Ecart();
return p;
......
usr/gri/pretty/selftest2.go
View file @ 4dc3d74a
......@@ -52,6 +52,17 @@ var (
)
func d0() {
var (
a string;
b, c string;
d, e, f string;
g, h, i, j string;
k, l, m, n, o string;
)
}
func f0(a, b int) int {
if a < b {
a = a + 1; // estimate
......
usr/gri/pretty/typechecker.go
View file @ 4dc3d74a
......@@ -17,10 +17,6 @@ import (
type State struct {
// setup
err Scanner.ErrorHandler;
// state
level int;
top_scope *Globals.Scope;
}
......@@ -54,66 +50,6 @@ func (s *State) Error(pos int, msg string) {
}
// ----------------------------------------------------------------------------
// Scopes
func (s *State) OpenScope() {
s.top_scope = Globals.NewScope(s.top_scope);
}
func (s *State) CloseScope() {
s.top_scope = s.top_scope.parent;
}
func (s *State) Lookup(ident string) *Globals.Object {
for scope := s.top_scope; scope != nil; scope = scope.parent {
obj := scope.Lookup(ident);
if obj != nil {
return obj;
}
}
return nil;
}
func (s *State) DeclareInScope(scope *Globals.Scope, obj *Globals.Object) {
if s.level > 0 {
panic("cannot declare objects in other packages");
}
obj.pnolev = s.level;
if scope.Lookup(obj.ident) != nil {
s.Error(obj.pos, `"` + obj.ident + `" is declared already`);
return; // don't insert it into the scope
}
scope.Insert(obj);
}
func (s *State) Declare(obj *Globals.Object) {
s.DeclareInScope(s.top_scope, obj);
}
// ----------------------------------------------------------------------------
// Common productions
func (s *State) DeclareIdent(ident *AST.Expr, kind int, typ *AST.Type) {
// ident is either a comma-separated list or a single ident
switch ident.tok {
case Scanner.IDENT:
obj := Globals.NewObject(ident.pos, kind, ident.obj.ident);
s.Declare(obj);
case Scanner.COMMA:
s.DeclareIdent(ident.x, kind, typ);
s.DeclareIdent(ident.y, kind, typ);
default:
unreachable();
}
}
// ----------------------------------------------------------------------------
func (s *State) CheckType() {
......@@ -131,48 +67,11 @@ func (s *State) CheckDeclaration(d *AST.Decl) {
// single declaration
switch d.tok {
case Scanner.IMPORT:
assert(d.ident == nil || d.ident.tok == Scanner.IDENT);
if d.ident != nil {
s.DeclareIdent(d.ident, d.tok, d.typ);
} else {
}
case Scanner.EXPORT:
// TODO
case Scanner.CONST:
s.DeclareIdent(d.ident, d.tok, d.typ);
case Scanner.VAR:
s.DeclareIdent(d.ident, d.tok, d.typ);
case Scanner.TYPE:
assert(d.ident.tok == Scanner.IDENT);
// types may be forward-declared
obj := s.Lookup(d.ident.obj.ident);
if obj != nil {
// TODO check if proper forward-declaration
} else {
s.DeclareIdent(d.ident, d.tok, d.typ);
}
case Scanner.FUNC:
assert(d.ident.tok == Scanner.IDENT);
if d.typ.key != nil {
// method
// TODO
} else {
// functions may be forward-declared
obj := s.Lookup(d.ident.obj.ident);
if obj != nil {
// TODO check if proper forward-declaration
} else {
s.DeclareIdent(d.ident, d.tok, d.typ);
}
}
default:
unreachable();
}
......@@ -181,16 +80,9 @@ func (s *State) CheckDeclaration(d *AST.Decl) {
func (s *State) CheckProgram(p *AST.Program) {
s.OpenScope();
{ s.OpenScope();
for i := 0; i < p.decls.Len(); i++ {
s.CheckDeclaration(p.decls.At(i).(*AST.Decl));
}
s.CloseScope();
for i := 0; i < p.decls.Len(); i++ {
s.CheckDeclaration(p.decls.At(i).(*AST.Decl));
}
s.CloseScope();
}
......
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