Merge pull request 'parser-cache' (#4) from parser-cache into main

Reviewed-on: arf/arf#4

parser/cache.go

@@ -0,0 +1,11 @@
+package parser
+
+// cacheItem stores an item of the parser cache.
+type cacheItem struct {
+	tree    SyntaxTree
+	skimmed bool
+}
+
+// cache stores all modules that have been parsed so far. They are indexed with
+// their full path on the filesystem, starting with '/'.
+var cache = make(map[string] cacheItem)

parser/parser.go

@@ -18,15 +18,28 @@ type ParsingOperation struct {
 }
 
 // TODO:
-// - implement parser cache
+// * implement parser cache
-// - have this try to hit the cache, and actually parse on miss
+// * have this try to hit the cache, and actually parse on miss
-// - rename this to Fetch
+// * rename this to Fetch
 // - add `skim bool` argument. when this is true, don't parse any code or data
 //   section initialization values, just definitions and their default values.
 
-// Parse reads the files located in the module specified by modulePath, and
+// Fetch returns the parsed module located at the specified path, and returns an
-// converts them into an abstract syntax tree.
+// abstract syntax tree. If the module has not yet been parsed, it parses it
-func Parse (modulePath string) (tree SyntaxTree, err error) {
+// first.
+func Fetch (modulePath string, skim bool) (tree SyntaxTree, err error) {
+	if modulePath[0] != '/' {
+		panic("module path did not begin at filesystem root")
+	}
+
+	// try to hit cache
+	cached, exists := cache[modulePath]
+	if exists && !(!skim && cached.skimmed){
+		tree = cached.tree
+		return
+	}
+
+	// miss, so parse the module.
 	parser := ParsingOperation {
 		modulePath: modulePath,
 		tree: SyntaxTree {
@@ -56,6 +69,13 @@ func Parse (modulePath string) (tree SyntaxTree, err error) {
 	}
 	
 	tree = parser.tree
+
+	// cache tree
+	cache[modulePath] = cacheItem {
+		tree:    tree,
+		skimmed: false,
+	}
+	
 	return
 }
 

parser/test-common.go

@@ -1,12 +1,16 @@
 package parser
 
 import "io"
+import "os"
 import "strings"
 import "testing"
-// import "git.tebibyte.media/arf/arf/types"
+import "path/filepath"
 
 func checkTree (modulePath string, correct string, test *testing.T) {
-	tree, err := Parse(modulePath)
+	cwd, _ := os.Getwd()
+	modulePath = filepath.Join(cwd, modulePath)
+	println(modulePath)
+	tree, err := Fetch(modulePath, false)
 	
 	treeString := tree.ToString(0)
 	treeRunes  := []rune(treeString)