Change the tree structure so it is compatible with the standard layout

of golang projects.

raku/raku.go

@@ -0,0 +1,152 @@
+// raku
+
+/* Raku is an easy to use scripting language that can also be used easily interactively
+
+Syntax (verified LL(1) )
+
+PROGRAM -> STATEMENTS .
+STATEMENTS -> STATEMENT STATEMENTS | .
+STATEMENT -> EXPRESSION | BLOCK | EMPTY_LINE | comment .
+EXPRESSION -> VALUE PARAMETERS NL.
+PARAMETERS_NONEMPTY -> PARAMETER PARAMETERS.
+PARAMETERS-> PARAMETERS_NONEMPTY | .
+PARAMETER -> BLOCK | VALUE .
+EMPTY_LINE -> NL .
+BLOCK -> ob STATEMENTS cb | op STATEMENTS cp | oa STATEMENTS ca.
+NL -> nl | semicolon .
+VALUE -> string | float | integer | symbol .
+
+Lexer:
+
+
+*/
+package raku
+
+import (
+	"fmt"
+	"io"
+)
+
+type Value string
+type TokenType int
+
+type Position struct {
+	Index  int
+	Row    int
+	Column int
+}
+
+const (
+	TokenError TokenType = iota
+	TokenEOF
+)
+
+type Token struct {
+	TokenType
+	Value
+	Position
+}
+
+func (me Token) String() string {
+	return fmt.Sprintf("Token: %d >%s< %d %d %d.", me.TokenType, string(me.Value), me.Index, me.Row, me.Column)
+}
+
+type TokenChannel chan Token
+
+type Lexer struct {
+	Reader  io.Reader
+	Current Position
+	Last    Position
+	Token   Token
+	rule    LexerRule
+	Output  TokenChannel
+	buffer  []byte
+}
+
+type LexerRule func(lexer *Lexer) LexerRule
+
+func (lexer *Lexer) Emit(t TokenType, v Value) {
+	tok := Token{t, v, lexer.Current}
+	lexer.Output <- tok
+}
+
+func (lexer *Lexer) Error(message string, args ...interface{}) {
+	value := fmt.Sprintf(message, args...)
+	lexer.Emit(TokenError, Value(value))
+}
+
+func LexError(lexer *Lexer) LexerRule {
+	lexer.Error("Error")
+	return nil
+}
+
+func LexNormal(lexer *Lexer) LexerRule {
+	return LexError
+}
+
+func OpenLexer(reader io.Reader) *Lexer {
+	lexer := &Lexer{}
+	lexer.Reader = reader
+	lexer.Output = make(TokenChannel)
+	// lexer.buffer = new(byte[1024])
+	return lexer
+}
+
+func (me *Lexer) ReadReader() (bool, error) {
+	buffer := make([]byte, 1024)
+
+	n, err := me.Reader.Read(buffer)
+	if n > 0 {
+		me.buffer = append(me.buffer, buffer...)
+	}
+	if err == io.EOF {
+		me.Emit(TokenEOF, "")
+		return true, nil
+	} else if err != nil {
+		me.Error("Error reading from reader: %s", err)
+		return true, err
+	}
+	return false, nil
+}
+
+func (me *Lexer) Start() {
+	more, err := me.ReadReader()
+	for err == nil && more {
+		more, err = me.ReadReader()
+	}
+
+	if err != nil {
+		return
+	}
+
+	rule := LexNormal
+	for rule != nil {
+		rule = rule(me)
+	}
+
+	close(me.Output)
+}
+
+/*
+func (me *Lexer) TryLexing() {
+	go {
+		me.Start()
+	}
+
+	for token := range me.Output {
+		fmt.Println("Token %s", token)
+	}
+}
+*/
+
+type Parser struct {
+	Lexer
+}
+
+type Environment struct {
+	Parent *Environment
+}
+
+func main() {
+	fmt.Println("Hello World!")
+}