added parseLetStatement

Author: uchiiii

.README.md.swp

@@ -0,0 +1,18 @@
+on: [push, pull_request]
+name: Test
+jobs:
+  test:
+    strategy:
+      matrix:
+        go-version: [1.13.x, 1.12.x]
+        platform: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.platform }}
+    steps:
+    - name: Install Go
+      uses: actions/setup-go@v1
+      with:
+        go-version: ${{ matrix.go-version }}
+    - name: Checkout code
+      uses: actions/checkout@v2
+    - name: Test
+      run: go test ./...

.github/workflows/test.yml

@@ -2,46 +2,45 @@ package ast
 
 import "github.com/uchiiii/gibbon/token"
 
-type Node interface{
+type Node interface {
 	TokenLiteral() string
 }
 
-type Statement interface{
+type Statement interface {
 	Node
 	statementNode()
 }
 
-type Expression interface{
+type Expression interface {
 	Node
 	expressionNode()
 }
 
-type Program struct{
+type Program struct {
 	Statements []Statement
 }
 
-func (p* Program) TokenLiteral() string{
-	if len(p.Statements) > 0{
+func (p *Program) TokenLiteral() string {
+	if len(p.Statements) > 0 {
 		return p.Statements[0].TokenLiteral()
-	}else{
+	} else {
 		return ""
 	}
 }
 
-type LetStatement struct{
+type LetStatement struct {
 	Token token.Token
-	Name *Identifier
+	Name  *Identifier
 	Value Expression
 }
 
-func (ls *LetStatement) statementNode(){}
-func (ls *LetStatement) TokenLiteral() string {return ls.Token.Literal}
+func (ls *LetStatement) statementNode()       {}
+func (ls *LetStatement) TokenLiteral() string { return ls.Token.Literal }
 
-type Identifier struct{
-	Token token.Token 
+type Identifier struct {
+	Token token.Token
 	Value string
 }
 
-func (i *Identifier) expressionNode(){}
-func (i *Identifier) TokenLiteral() string {return i.Token.Literal}
-
+func (i *Identifier) expressionNode()      {}
+func (i *Identifier) TokenLiteral() string { return i.Token.Literal }

ast/ast.go

@@ -2,42 +2,42 @@ package lexer
 
 import "github.com/uchiiii/gibbon/token"
 
-type lexer struct{
-	input string
-	position int 
+type Lexer struct {
+	input        string
+	position     int
 	readPosition int
-	ch byte
+	ch           byte
 }
 
-func New(input string) *lexer{
-	l := &lexer{input: input}
+func New(input string) *Lexer {
+	l := &Lexer{input: input}
 	l.readChar()
 	return l
 }
 
-func (l *lexer) readChar(){
-	if l.readPosition >= len(l.input){
+func (l *Lexer) readChar() {
+	if l.readPosition >= len(l.input) {
 		l.ch = 0
-	}else{
+	} else {
 		l.ch = l.input[l.readPosition]
 	}
 	l.position = l.readPosition
 	l.readPosition += 1
 }
 
-func (l *lexer) NextToken() token.Token {
+func (l *Lexer) NextToken() token.Token {
 	var tok token.Token
 
 	l.skipWhitespace()
 
-	switch l.ch{
+	switch l.ch {
 	case '=':
-		if l.peekChar() == '='{
+		if l.peekChar() == '=' {
 			ch := l.ch
 			l.readChar()
 			literal := string(ch) + string(l.ch)
 			tok = token.Token{Type: token.EQ, Literal: literal}
-		}else{
+		} else {
 			tok = newToken(token.ASSIGN, l.ch)
 		}
 	case ';':
@@ -53,12 +53,12 @@ func (l *lexer) NextToken() token.Token {
 	case '-':
 		tok = newToken(token.MINUS, l.ch)
 	case '!':
-		if l.peekChar() == '='{
+		if l.peekChar() == '=' {
 			ch := l.ch
 			l.readChar()
 			literal := string(ch) + string(l.ch)
 			tok = token.Token{Type: token.NOT_EQ, Literal: literal}
-		}else{
+		} else {
 			tok = newToken(token.BANG, l.ch)
 		}
 	case '/':
@@ -77,11 +77,11 @@ func (l *lexer) NextToken() token.Token {
 		tok.Literal = ""
 		tok.Type = token.EOF
 	default:
-		if isLetter(l.ch){
+		if isLetter(l.ch) {
 			tok.Literal = l.readIdentifier()
 			tok.Type = token.LookupIdent(tok.Literal)
 			return tok
-		} else if isDigit(l.ch){
+		} else if isDigit(l.ch) {
 			tok.Type = token.INT
 			tok.Literal = l.readNumber()
 			return tok
@@ -94,44 +94,44 @@ func (l *lexer) NextToken() token.Token {
 	return tok
 }
 
-func newToken(tokenType token.TokenType, ch byte) token.Token{
+func newToken(tokenType token.TokenType, ch byte) token.Token {
 	return token.Token{Type: tokenType, Literal: string(ch)}
 }
 
-func (l *lexer) readIdentifier() string{
+func (l *Lexer) readIdentifier() string {
 	position := l.position
-	for isLetter(l.ch){
+	for isLetter(l.ch) {
 		l.readChar()
 	}
 	return l.input[position:l.position]
 }
 
-func isLetter(ch byte) bool{
+func isLetter(ch byte) bool {
 	return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_'
 }
 
-func (l *lexer) skipWhitespace(){
-	for l.ch == ' ' || l.ch == '\t' || l.ch == '\n' || l.ch == '\r'{
+func (l *Lexer) skipWhitespace() {
+	for l.ch == ' ' || l.ch == '\t' || l.ch == '\n' || l.ch == '\r' {
 		l.readChar()
 	}
 }
 
-func (l *lexer) readNumber() string{
+func (l *Lexer) readNumber() string {
 	position := l.position
-	for isDigit(l.ch){
+	for isDigit(l.ch) {
 		l.readChar()
 	}
 	return l.input[position:l.position]
 }
 
-func isDigit(ch byte) bool{
+func isDigit(ch byte) bool {
 	return '0' <= ch && ch <= '9'
 }
 
-func (l *lexer) peekChar() byte{
-	if l.readPosition >= len(l.input){
+func (l *Lexer) peekChar() byte {
+	if l.readPosition >= len(l.input) {
 		return 0
-	}else{
+	} else {
 		return l.input[l.readPosition]
 	}
 }

lexer/lexer.go

@@ -1,11 +1,11 @@
 package lexer
 
 import (
-	"testing"
 	"github.com/uchiiii/gibbon/token"
+	"testing"
 )
 
-func TestNextToken(t *testing.T){
+func TestNextToken(t *testing.T) {
 	input := `let five = 5;
 	let ten = 10;
 
@@ -27,8 +27,8 @@ func TestNextToken(t *testing.T){
 	10 != 9;
 	`
 
-	tests := []struct{
-		expectedType token.TokenType
+	tests := []struct {
+		expectedType    token.TokenType
 		expectedLiteral string
 	}{
 		{token.LET, "let"},
@@ -109,9 +109,9 @@ func TestNextToken(t *testing.T){
 
 	l := New(input)
 
-	for i,tt := range tests {
+	for i, tt := range tests {
 		tok := l.NextToken()
-		
+
 		if tok.Type != tt.expectedType {
 			t.Fatalf("tests[%d] - tokentype wrong. expected=%q, got=%q", i, tt.expectedType, tok.Type)
 		}

lexer/lexer_test.go

@@ -2,14 +2,14 @@ package main
 
 import (
 	"fmt"
+	"github.com/uchiiii/gibbon/repl"
 	"os"
 	"os/user"
-	"github.com/uchiiii/gibbon/repl"
 )
 
-func main(){
+func main() {
 	user, err := user.Current()
-	if err != nil{
+	if err != nil {
 		panic(err)
 	}
 	fmt.Printf("Hello %s! This is gibbon Programming language!\n", user.Username)

main.go

@@ -1,31 +1,91 @@
 package parser
 
 import (
-	"github.com/uchiiii/gibbon/token"
 	"github.com/uchiiii/gibbon/ast"
-	"github.com/uchiiii/gibbin/lexer"
+	"github.com/uchiiii/gibbon/lexer"
+	"github.com/uchiiii/gibbon/token"
 )
 
-type Parser struct{
+type Parser struct {
 	l *lexer.Lexer
 
-	curToken token.Token
+	curToken  token.Token
 	peekToken token.Token
 }
 
-func New(l *lexer.Lexer) *Parser{
+func New(l *lexer.Lexer) *Parser {
 	p := &Parser{l: l}
 	p.nextToken()
 	p.nextToken()
 
 	return p
 }
 
-func (p *Parser) nextToken(){
+func (p *Parser) nextToken() {
 	p.curToken = p.peekToken
 	p.peekToken = p.l.NextToken()
 }
 
-func (p *Parser) ParseProgram() *ast.Program{
-	return nil
+func (p *Parser) ParseProgram() *ast.Program {
+	program := &ast.Program{}
+	program.Statements = []ast.Statement{}
+
+	for p.curToken.Type != token.EOF {
+		stmt := p.parseStatement()
+		if stmt != nil {
+			program.Statements = append(program.Statements, stmt)
+		}
+		p.nextToken()
+	}
+
+	return program
+}
+
+func (p *Parser) parseStatement() ast.Statement {
+	switch p.curToken.Type {
+	case token.LET:
+		return p.parseLetStatement()
+	default:
+		return nil
+	}
+}
+
+func (p *Parser) parseLetStatement() *ast.LetStatement {
+	stmt := &ast.LetStatement{Token: p.curToken}
+
+	if !p.expectPeek(token.IDENT) {
+		return nil
+	}
+
+	stmt.Name = &ast.Identifier{
+		Token: p.curToken,
+		Value: p.curToken.Literal,
+	}
+
+	if !p.expectPeek(token.ASSIGN) {
+		return nil
+	}
+
+	for !p.curTokenIs(token.SEMICOLON) {
+		p.nextToken()
+	}
+
+	return stmt
+}
+
+func (p *Parser) curTokenIs(t token.TokenType) bool {
+	return p.curToken.Type == t
+}
+
+func (p *Parser) peekTokenIs(t token.TokenType) bool {
+	return p.peekToken.Type == t
+}
+
+func (p *Parser) expectPeek(t token.TokenType) bool {
+	if p.peekTokenIs(t) {
+		p.nextToken()
+		return true
+	} else {
+		return false
+	}
 }