Created base for parser

The parser now handles file opening and invokes the lexer.

main.go

@@ -1,23 +1,9 @@
 package arf
 
-import "os"
 import "io"
-import "path/filepath"
+import "github.com/sashakoshka/arf/parser"
-// import "github.com/sashakoshka/arf/lexer"
 
 func CompileModule (modulePath string, output io.Writer) (err error) {
-	moduleFiles, err := os.ReadDir(modulePath)
+	_, err = parser.Parse(modulePath)
-	if err != nil { return err }
-
-	// var moduleTokens []lexer.Token
-	for _, entry := range moduleFiles {
-		if filepath.Ext(entry.Name()) != ".arf" || entry.IsDir() {
-			continue
-		}
-
-		// tokens, err := lexer.Tokenize()
-		// if err != nil { return err }
-	}
-
 	return
 }

parser/parser.go

@@ -0,0 +1,49 @@
+package parser
+
+import "os"
+import "path/filepath"
+import "github.com/sashakoshka/arf/file"
+import "github.com/sashakoshka/arf/lexer"
+
+// ParsingOperation holds information about an ongoing parsing operation.
+type ParsingOperation struct {
+	modulePath string
+	token      lexer.Token
+	tokens     []lexer.Token
+	tokenIndex int
+}
+
+// Parse reads the files located in the module specified by modulePath, and
+// converts them into an abstract syntax tree.
+func Parse (modulePath string) (tree *SyntaxTree, err error) {
+	parser := ParsingOperation { modulePath: modulePath }
+	tree, err = parser.parse()
+	return
+}
+
+// parse runs the parsing operation.
+func (parser *ParsingOperation) parse () (tree *SyntaxTree, err error) {
+	if parser.modulePath[len(parser.modulePath) - 1] != '/' {
+		parser.modulePath += "/"
+	}
+
+	var moduleFiles []os.DirEntry
+	moduleFiles, err = os.ReadDir(parser.modulePath)
+	if err != nil { return }
+
+	for _, entry := range moduleFiles {
+		if filepath.Ext(entry.Name()) != ".arf" || entry.IsDir() {
+			continue
+		}
+
+		var sourceFile *file.File
+		sourceFile, err = file.Open(parser.modulePath + entry.Name())
+		if err != nil { return }
+
+		var tokens []lexer.Token
+		tokens, err = lexer.Tokenize(sourceFile)
+		if err != nil { return }
+		parser.tokens = append(parser.tokens, tokens...)
+	}
+	return
+}

parser/tree.go

@@ -0,0 +1,8 @@
+package parser
+
+// SyntaxTree represents an abstract syntax tree. It covers an entire module. It
+// can be expected to be syntactically correct, but it might not be semantically
+// correct (because it has not been analyzed yet.)
+type SyntaxTree struct {
+	
+}