Simplified file structure

src/scanner/Scan.go

@@ -0,0 +1,25 @@
+package scanner
+
+import (
+	"git.akyoto.dev/cli/q/src/core"
+	"git.akyoto.dev/cli/q/src/fs"
+)
+
+// Scan scans the list of files.
+func Scan(files []string) (<-chan *fs.File, <-chan *core.Function, <-chan error) {
+	scanner := Scanner{
+		files:     make(chan *fs.File),
+		functions: make(chan *core.Function),
+		errors:    make(chan error),
+	}
+
+	go func() {
+		scanner.queue(files...)
+		scanner.group.Wait()
+		close(scanner.files)
+		close(scanner.functions)
+		close(scanner.errors)
+	}()
+
+	return scanner.files, scanner.functions, scanner.errors
+}

src/scanner/Scanner.go

@@ -0,0 +1,17 @@
+package scanner
+
+import (
+	"sync"
+
+	"git.akyoto.dev/cli/q/src/core"
+	"git.akyoto.dev/cli/q/src/fs"
+)
+
+// Scanner is used to scan files before the actual compilation step.
+type Scanner struct {
+	files     chan *fs.File
+	functions chan *core.Function
+	errors    chan error
+	queued    sync.Map
+	group     sync.WaitGroup
+}

src/scanner/queue.go

@@ -0,0 +1,21 @@
+package scanner
+
+import "os"
+
+// queue scans the list of files.
+func (s *Scanner) queue(files ...string) {
+	for _, file := range files {
+		stat, err := os.Stat(file)
+
+		if err != nil {
+			s.errors <- err
+			return
+		}
+
+		if stat.IsDir() {
+			s.queueDirectory(file, "main")
+		} else {
+			s.queueFile(file, "main")
+		}
+	}
+}

src/scanner/queueDirectory.go

@@ -0,0 +1,30 @@
+package scanner
+
+import (
+	"path/filepath"
+	"strings"
+
+	"git.akyoto.dev/cli/q/src/fs"
+)
+
+// queueDirectory queues an entire directory to be scanned.
+func (s *Scanner) queueDirectory(directory string, pkg string) {
+	_, loaded := s.queued.LoadOrStore(directory, nil)
+
+	if loaded {
+		return
+	}
+
+	err := fs.Walk(directory, func(name string) {
+		if !strings.HasSuffix(name, ".q") {
+			return
+		}
+
+		fullPath := filepath.Join(directory, name)
+		s.queueFile(fullPath, pkg)
+	})
+
+	if err != nil {
+		s.errors <- err
+	}
+}

src/scanner/queueFile.go

@@ -0,0 +1,15 @@
+package scanner
+
+// queueFile queues a single file to be scanned.
+func (s *Scanner) queueFile(file string, pkg string) {
+	s.group.Add(1)
+
+	go func() {
+		defer s.group.Done()
+		err := s.scanFile(file, pkg)
+
+		if err != nil {
+			s.errors <- err
+		}
+	}()
+}

src/scanner/scanFile.go

@@ -0,0 +1,281 @@
+package scanner
+
+import (
+	"os"
+	"path/filepath"
+
+	"git.akyoto.dev/cli/q/src/arch/x64"
+	"git.akyoto.dev/cli/q/src/config"
+	"git.akyoto.dev/cli/q/src/core"
+	"git.akyoto.dev/cli/q/src/errors"
+	"git.akyoto.dev/cli/q/src/fs"
+	"git.akyoto.dev/cli/q/src/scope"
+	"git.akyoto.dev/cli/q/src/token"
+	"git.akyoto.dev/cli/q/src/types"
+)
+
+// scanFile scans a single file.
+func (s *Scanner) scanFile(path string, pkg string) error {
+	contents, err := os.ReadFile(path)
+
+	if err != nil {
+		return err
+	}
+
+	tokens := token.Tokenize(contents)
+
+	file := &fs.File{
+		Path:    path,
+		Bytes:   contents,
+		Tokens:  tokens,
+		Package: pkg,
+	}
+
+	s.files <- file
+
+	var (
+		i           = 0
+		groupLevel  = 0
+		blockLevel  = 0
+		nameStart   = -1
+		paramsStart = -1
+		paramsEnd   = -1
+		bodyStart   = -1
+		typeStart   = -1
+		typeEnd     = -1
+	)
+
+	for {
+		for i < len(tokens) && tokens[i].Kind == token.Import {
+			i++
+
+			if tokens[i].Kind != token.Identifier {
+				panic("expected package name")
+			}
+
+			packageName := tokens[i].Text(contents)
+
+			if file.Imports == nil {
+				file.Imports = map[string]*fs.Import{}
+			}
+
+			fullPath := filepath.Join(config.Library, packageName)
+
+			file.Imports[packageName] = &fs.Import{
+				Path:     packageName,
+				FullPath: fullPath,
+				Position: tokens[i].Position,
+			}
+
+			s.queueDirectory(fullPath, packageName)
+			i++
+
+			if tokens[i].Kind != token.NewLine && tokens[i].Kind != token.EOF {
+				panic("expected newline or eof")
+			}
+
+			i++
+		}
+
+		// Function name
+		for i < len(tokens) {
+			if tokens[i].Kind == token.Identifier {
+				nameStart = i
+				i++
+				break
+			}
+
+			if tokens[i].Kind == token.NewLine || tokens[i].Kind == token.Comment {
+				i++
+				continue
+			}
+
+			if tokens[i].Kind == token.Invalid {
+				return errors.New(&errors.InvalidCharacter{Character: tokens[i].Text(contents)}, file, tokens[i].Position)
+			}
+
+			if tokens[i].Kind == token.EOF {
+				return nil
+			}
+
+			return errors.New(errors.ExpectedFunctionName, file, tokens[i].Position)
+		}
+
+		// Function parameters
+		for i < len(tokens) {
+			if tokens[i].Kind == token.GroupStart {
+				groupLevel++
+				i++
+
+				if groupLevel == 1 {
+					paramsStart = i
+				}
+
+				continue
+			}
+
+			if tokens[i].Kind == token.GroupEnd {
+				groupLevel--
+
+				if groupLevel < 0 {
+					return errors.New(errors.MissingGroupStart, file, tokens[i].Position)
+				}
+
+				if groupLevel == 0 {
+					paramsEnd = i
+					i++
+					break
+				}
+
+				i++
+				continue
+			}
+
+			if tokens[i].Kind == token.Invalid {
+				return errors.New(&errors.InvalidCharacter{Character: tokens[i].Text(contents)}, file, tokens[i].Position)
+			}
+
+			if tokens[i].Kind == token.EOF {
+				if groupLevel > 0 {
+					return errors.New(errors.MissingGroupEnd, file, tokens[i].Position)
+				}
+
+				if paramsStart == -1 {
+					return errors.New(errors.ExpectedFunctionParameters, file, tokens[i].Position)
+				}
+
+				return nil
+			}
+
+			if groupLevel > 0 {
+				i++
+				continue
+			}
+
+			return errors.New(errors.ExpectedFunctionParameters, file, tokens[i].Position)
+		}
+
+		// Return type
+		if i < len(tokens) && tokens[i].Kind == token.ReturnType {
+			typeStart = i + 1
+
+			for i < len(tokens) && tokens[i].Kind != token.BlockStart {
+				i++
+			}
+
+			typeEnd = i
+		}
+
+		// Function definition
+		for i < len(tokens) {
+			if tokens[i].Kind == token.ReturnType {
+				i++
+				continue
+			}
+
+			if tokens[i].Kind == token.BlockStart {
+				blockLevel++
+				i++
+
+				if blockLevel == 1 {
+					bodyStart = i
+				}
+
+				continue
+			}
+
+			if tokens[i].Kind == token.BlockEnd {
+				blockLevel--
+
+				if blockLevel < 0 {
+					return errors.New(errors.MissingBlockStart, file, tokens[i].Position)
+				}
+
+				if blockLevel == 0 {
+					break
+				}
+
+				i++
+				continue
+			}
+
+			if tokens[i].Kind == token.Invalid {
+				return errors.New(&errors.InvalidCharacter{Character: tokens[i].Text(contents)}, file, tokens[i].Position)
+			}
+
+			if tokens[i].Kind == token.EOF {
+				if blockLevel > 0 {
+					return errors.New(errors.MissingBlockEnd, file, tokens[i].Position)
+				}
+
+				if bodyStart == -1 {
+					return errors.New(errors.ExpectedFunctionDefinition, file, tokens[i].Position)
+				}
+
+				return nil
+			}
+
+			if blockLevel > 0 {
+				i++
+				continue
+			}
+
+			return errors.New(errors.ExpectedFunctionDefinition, file, tokens[i].Position)
+		}
+
+		name := tokens[nameStart].Text(contents)
+		body := tokens[bodyStart:i]
+		function := core.NewFunction(pkg, name, file, body)
+
+		if typeStart != -1 {
+			if tokens[typeStart].Kind == token.GroupStart && tokens[typeEnd-1].Kind == token.GroupEnd {
+				typeStart++
+				typeEnd--
+			}
+
+			function.ReturnTypes = types.NewList(tokens[typeStart:typeEnd], contents)
+		}
+
+		parameters := tokens[paramsStart:paramsEnd]
+		count := 0
+
+		err := parameters.Split(func(tokens token.List) error {
+			if len(tokens) < 2 {
+				return errors.New(errors.MissingType, file, tokens[0].End())
+			}
+
+			name := tokens[0].Text(contents)
+			dataType := types.New(tokens[1:].Text(contents))
+			register := x64.InputRegisters[count]
+			uses := token.Count(function.Body, contents, token.Identifier, name)
+
+			if uses == 0 {
+				return errors.New(&errors.UnusedVariable{Name: name}, file, tokens[0].Position)
+			}
+
+			variable := &scope.Variable{
+				Name:     name,
+				Type:     dataType,
+				Register: register,
+				Alive:    uses,
+			}
+
+			function.Parameters = append(function.Parameters, variable)
+			function.AddVariable(variable)
+			count++
+			return nil
+		})
+
+		if err != nil {
+			return err
+		}
+
+		s.functions <- function
+		nameStart = -1
+		paramsStart = -1
+		bodyStart = -1
+		typeStart = -1
+		typeEnd = -1
+		i++
+	}
+}