§2.7: added temporary tracing instructions.

parser/parser.go

@@ -91,6 +91,7 @@ func (p *Parser) Errors() []string {
 // ParseProgram is the outermost parsing logic, accumulating statements in a
 // Program instance and returning that instance once parsing is done.
 func (p *Parser) ParseProgram() *ast.Program {
+	defer untrace(trace("ParseProgram"))
 	program := &ast.Program{
 		Statements: []ast.Statement{},
 	}
@@ -107,8 +108,8 @@ func (p *Parser) ParseProgram() *ast.Program {
 
 // Return the precedence for the current token without advancing.
 func (p *Parser) curPrecedence() int {
-	if p, ok := precedences[p.curToken.Type]; ok {
-		return p
+	if precedence, ok := precedences[p.curToken.Type]; ok {
+		return precedence
 	}
 
 	return LOWEST
@@ -138,6 +139,7 @@ func (p *Parser) nextToken() {
 }
 
 func (p *Parser) parseStatement() ast.Statement {
+	defer untrace(trace("parseStatement"))
 	switch p.curToken.Type {
 	case token.LET:
 		return p.parseLetStatement()
@@ -159,8 +161,8 @@ func (p *Parser) peekError(t token.TokenType) {
 
 // Look forward for the precedence of the next token without advancing.
 func (p *Parser) peekPrecedence() int {
-	if p, ok := precedences[p.peekToken.Type]; ok {
-		return p
+	if precedence, ok := precedences[p.peekToken.Type]; ok {
+		return precedence
 	}
 
 	return LOWEST

parser/parser_expression.go

@@ -13,6 +13,7 @@ func (p *Parser) noPrefixParseFnError(t token.TokenType) {
 }
 
 func (p *Parser) parseExpression(precedence int) ast.Expression {
+	defer untrace(trace("parseExpression"))
 	prefix := p.prefixParseFns[p.curToken.Type]
 	if prefix == nil {
 		p.noPrefixParseFnError(p.curToken.Type)
@@ -35,6 +36,7 @@ func (p *Parser) parseExpression(precedence int) ast.Expression {
 }
 
 func (p *Parser) parseExpressionStatement() *ast.ExpressionStatement {
+	defer untrace(trace("parseExpressionStatement"))
 	stmt := &ast.ExpressionStatement{
 		Token: p.curToken,
 	}

parser/parser_infix.go

@@ -5,6 +5,7 @@ import (
 )
 
 func (p *Parser) parseInfixExpression(left ast.Expression) ast.Expression {
+	defer untrace(trace("parseInfixExpression"))
 	expression := &ast.InfixExpression{
 		Token:    p.curToken,
 		Operator: p.curToken.Literal,

parser/parser_int.go

@@ -8,6 +8,7 @@ import (
 )
 
 func (p *Parser) parseIntegerLiteral() ast.Expression {
+	defer untrace(trace("parseIntegerLiteral"))
 	lit := &ast.IntegerLiteral{
 		Token: p.curToken,
 	}

parser/parser_let.go

@@ -6,6 +6,7 @@ import (
 )
 
 func (p *Parser) parseLetStatement() *ast.LetStatement {
+	defer untrace(trace("parseLetStatement"))
 	stmt := &ast.LetStatement{
 		Token: p.curToken,
 	}

parser/parser_prefix.go

@@ -5,6 +5,7 @@ import (
 )
 
 func (p *Parser) parsePrefixExpression() ast.Expression {
+	defer untrace(trace("parsePrefixExpression"))
 	expression := &ast.PrefixExpression{
 		Token:    p.curToken,
 		Operator: p.curToken.Literal,

parser/parser_return.go

@@ -6,6 +6,7 @@ import (
 )
 
 func (p *Parser) parseReturnStatement() *ast.ReturnStatement {
+	defer untrace(trace("parseReturnStatement"))
 	stmt := &ast.ReturnStatement{
 		Token: p.curToken,
 	}

parser/parser_tracing.go

@@ -0,0 +1,37 @@
+package parser
+
+import (
+	"fmt"
+	"strings"
+)
+
+const traceIndentPlaceholder = "\t"
+
+var traceLevel = 0
+
+func tracePrint(fs string) {
+	fmt.Printf("%s%s\n", indentLevel(), fs)
+}
+
+func indentDec() {
+	traceLevel--
+}
+
+func indentInc() {
+	traceLevel++
+}
+
+func indentLevel() string {
+	return strings.Repeat(traceIndentPlaceholder, traceLevel-1)
+}
+
+func trace(msg string) string {
+	indentInc()
+	tracePrint("BEGIN " + msg)
+	return msg
+}
+
+func untrace(msg string) {
+	tracePrint("END " + msg)
+	indentDec()
+}