Implemented package imports

src/build/scanner/scanFile.go

@@ -0,0 +1,238 @@
+package scanner
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"git.akyoto.dev/cli/q/src/build/arch/x64"
+	"git.akyoto.dev/cli/q/src/build/config"
+	"git.akyoto.dev/cli/q/src/build/core"
+	"git.akyoto.dev/cli/q/src/build/errors"
+	"git.akyoto.dev/cli/q/src/build/expression"
+	"git.akyoto.dev/cli/q/src/build/fs"
+	"git.akyoto.dev/cli/q/src/build/keyword"
+	"git.akyoto.dev/cli/q/src/build/token"
+)
+
+// 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{
+		Tokens: tokens,
+		Path:   path,
+	}
+
+	var (
+		i           = 0
+		groupLevel  = 0
+		blockLevel  = 0
+		nameStart   = -1
+		paramsStart = -1
+		paramsEnd   = -1
+		bodyStart   = -1
+	)
+
+	for {
+		for i < len(tokens) && tokens[i].Kind == token.Keyword && tokens[i].Text() == keyword.Import {
+			i++
+
+			if tokens[i].Kind != token.Identifier {
+				panic("expected package name")
+			}
+
+			packageName := tokens[i].Text()
+			s.queueDirectory(filepath.Join(config.Library, packageName), 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()}, 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()}, 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)
+		}
+
+		// Function definition
+		for i < len(tokens) {
+			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()}, 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()
+		body := tokens[bodyStart:i]
+
+		if pkg != "" {
+			name = fmt.Sprintf("%s.%s", pkg, name)
+		}
+
+		function := core.NewFunction(name, file, body)
+		parameters := tokens[paramsStart:paramsEnd]
+		count := 0
+
+		err := expression.EachParameter(parameters, func(tokens token.List) error {
+			if len(tokens) != 1 {
+				return errors.New(errors.NotImplemented, file, tokens[0].Position)
+			}
+
+			name := tokens[0].Text()
+			register := x64.CallRegisters[count]
+			uses := token.Count(function.Body, token.Identifier, name)
+
+			if uses == 0 {
+				return errors.New(&errors.UnusedVariable{Name: name}, file, tokens[0].Position)
+			}
+
+			variable := &core.Variable{
+				Name:     name,
+				Register: register,
+				Alive:    uses,
+			}
+
+			function.AddVariable(variable)
+			count++
+			return nil
+		})
+
+		if err != nil {
+			return err
+		}
+
+		s.functions <- function
+		nameStart = -1
+		paramsStart = -1
+		bodyStart = -1
+		i++
+	}
+}