Merge pull request #3 from looplanguage/feat_import_statement

feat: import statement

Author: kanersps

.gitignore

@@ -1,2 +1,3 @@
 .idea
-compiler.exe
+compiler.exe
+packages/**

compiler/compile.go

@@ -10,29 +10,29 @@ import (
 
 var jumpReturns []*int
 
-func (c *Compiler) Compile(node ast.Node) error {
+func (c *Compiler) Compile(node ast.Node, root, identifier, previous string) error {
 	switch node := node.(type) {
 	case *ast.Program:
 		for _, stmt := range node.Statements {
-			err := c.Compile(stmt)
+			err := c.Compile(stmt, root, identifier, previous)
 			if err != nil {
 				return err
 			}
 		}
 	case *ast.ExpressionStatement:
-		err := c.Compile(node.Expression)
+		err := c.Compile(node.Expression, root, "", previous)
 		if err != nil {
 			return err
 		}
 		c.emit(code.OpPop)
 	case *ast.SuffixExpression:
 		if node.Operator == "<" {
-			err := c.Compile(node.Right)
+			err := c.Compile(node.Right, root, "", previous)
 			if err != nil {
 				return err
 			}
 
-			err = c.Compile(node.Left)
+			err = c.Compile(node.Left, root, "", previous)
 			if err != nil {
 				return err
 			}
@@ -41,12 +41,12 @@ func (c *Compiler) Compile(node ast.Node) error {
 			return nil
 		}
 
-		err := c.Compile(node.Left)
+		err := c.Compile(node.Left, root, "", previous)
 		if err != nil {
 			return err
 		}
 
-		err = c.Compile(node.Right)
+		err = c.Compile(node.Right, root, "", previous)
 		if err != nil {
 			return err
 		}
@@ -84,14 +84,14 @@ func (c *Compiler) Compile(node ast.Node) error {
 		}
 	case *ast.While:
 		startPos := len(c.currentInstructions())
-		err := c.Compile(node.Condition)
+		err := c.Compile(node.Condition, root, "", previous)
 		if err != nil {
 			return err
 		}
 
 		jumpPos := c.emit(code.OpJumpIfNotTrue, 9999)
 
-		err = c.Compile(node.Block)
+		err = c.Compile(node.Block, root, "", previous)
 		if err != nil {
 			return err
 		}
@@ -113,14 +113,14 @@ func (c *Compiler) Compile(node ast.Node) error {
 			jumpReturns = []*int{}
 		}
 	case *ast.ConditionalStatement:
-		err := c.Compile(node.Condition)
+		err := c.Compile(node.Condition, root, "", previous)
 		if err != nil {
 			return err
 		}
 
 		jumpPos := c.emit(code.OpJumpIfNotTrue, 9999)
 
-		err = c.Compile(node.Body)
+		err = c.Compile(node.Body, root, "", previous)
 		if err != nil {
 			return err
 		}
@@ -137,7 +137,7 @@ func (c *Compiler) Compile(node ast.Node) error {
 		if node.ElseCondition == nil && node.ElseStatement == nil {
 			c.emit(code.OpNull)
 		} else if node.ElseCondition != nil {
-			err := c.Compile(node.ElseCondition)
+			err := c.Compile(node.ElseCondition, root, "", previous)
 			if err != nil {
 				return nil
 			}
@@ -146,7 +146,7 @@ func (c *Compiler) Compile(node ast.Node) error {
 				c.removeLastPop()
 			}
 		} else if node.ElseStatement != nil {
-			err := c.Compile(node.ElseStatement)
+			err := c.Compile(node.ElseStatement, root, "", previous)
 			if err != nil {
 				return nil
 			}
@@ -166,7 +166,7 @@ func (c *Compiler) Compile(node ast.Node) error {
 	case *ast.BlockStatement:
 		c.currentScope = c.deeperScope()
 		for _, s := range node.Statements {
-			err := c.Compile(s)
+			err := c.Compile(s, root, "", previous)
 			if err != nil {
 				return err
 			}
@@ -176,35 +176,41 @@ func (c *Compiler) Compile(node ast.Node) error {
 	case *ast.VariableDeclaration:
 		index := c.variables
 
+		name := node.Identifier.Value
+
+		if root != "" {
+			name = "_INTERNAL_" + root + "" + name
+		}
+
 		c.currentScope.Variables[index] = Variable{
-			Name:   node.Identifier.Value,
+			Name:   name,
 			Index:  index,
 			Object: &object.Null{},
 		}
 
 		c.variables++
 
-		err := c.Compile(node.Value)
+		err := c.Compile(node.Value, root, "", previous)
 		if err != nil {
 			return err
 		}
 
 		c.emit(code.OpSetVar, index)
 	case *ast.Assign:
-		variable := c.currentScope.FindByName(node.Identifier.Value)
+		variable := c.currentScope.FindByName(node.Identifier.Value, root)
 
 		if variable == nil {
 			return fmt.Errorf("undefined variable %s", node.Identifier.Value)
 		}
 
-		err := c.Compile(node.Value)
+		err := c.Compile(node.Value, root, "", previous)
 		if err != nil {
 			return err
 		}
 
 		c.emit(code.OpSetVar, variable.Index)
 	case *ast.Identifier:
-		variable := c.currentScope.FindByName(node.Value)
+		variable := c.currentScope.FindByName(node.Value, root)
 
 		if variable != nil {
 			c.emit(code.OpGetVar, variable.Index)
@@ -217,20 +223,20 @@ func (c *Compiler) Compile(node ast.Node) error {
 		}
 	case *ast.Array:
 		for _, element := range node.Elements {
-			err := c.Compile(element)
+			err := c.Compile(element, root, "", previous)
 			if err != nil {
 				return err
 			}
 		}
 
 		c.emit(code.OpArray, len(node.Elements))
 	case *ast.IndexExpression:
-		err := c.Compile(node.Value)
+		err := c.Compile(node.Value, root, "", previous)
 		if err != nil {
 			return err
 		}
 
-		err = c.Compile(node.Index)
+		err = c.Compile(node.Index, root, "", previous)
 		if err != nil {
 			return err
 		}
@@ -248,11 +254,11 @@ func (c *Compiler) Compile(node ast.Node) error {
 		})
 
 		for _, k := range keys {
-			err := c.Compile(k)
+			err := c.Compile(k, root, "", previous)
 			if err != nil {
 				return err
 			}
-			err = c.Compile(node.Values[k])
+			err = c.Compile(node.Values[k], root, "", previous)
 			if err != nil {
 				return err
 			}
@@ -266,7 +272,7 @@ func (c *Compiler) Compile(node ast.Node) error {
 			c.symbolTable.Define(p.Value)
 		}
 
-		err := c.Compile(node.Body)
+		err := c.Compile(node.Body, root, "", previous)
 		if err != nil {
 			return err
 		}
@@ -299,7 +305,7 @@ func (c *Compiler) Compile(node ast.Node) error {
 			return fmt.Errorf("cannot have return statement in root scope")
 		}
 
-		err := c.Compile(node.Value)
+		err := c.Compile(node.Value, root, "", previous)
 		if err != nil {
 			return err
 		}
@@ -311,19 +317,42 @@ func (c *Compiler) Compile(node ast.Node) error {
 			jumpReturns = append(jumpReturns, &val)
 		}
 	case *ast.CallExpression:
-		err := c.Compile(node.Function)
+		err := c.Compile(node.Function, root, "", previous)
 		if err != nil {
 			return err
 		}
 
 		for _, arg := range node.Parameters {
-			err := c.Compile(arg)
+			err := c.Compile(arg, root, "", previous)
 			if err != nil {
 				return err
 			}
 		}
 
 		c.emit(code.OpCall, len(node.Parameters))
+	case *ast.Import:
+		err := c.importPackage(root, node)
+
+		if err != nil {
+			return err
+		}
+	case *ast.Export:
+		index := c.variables
+
+		c.currentScope.Variables[index] = Variable{
+			Name:   identifier,
+			Index:  index,
+			Object: &object.Null{},
+		}
+
+		c.variables++
+
+		err := c.Compile(node.Expression, root, identifier, previous)
+		if err != nil {
+			return err
+		}
+
+		c.emit(code.OpSetVar, index)
 	}
 
 	return nil

compiler/compiler.go

@@ -24,15 +24,26 @@ type VariableScope struct {
 	Outer     *VariableScope
 }
 
-func (vs *VariableScope) FindByName(name string) *Variable {
-	for _, v := range vs.Variables {
-		if v.Name == name {
-			return &v
+func (vs *VariableScope) FindByName(name, root string) *Variable {
+	if root == "" {
+		for _, v := range vs.Variables {
+			if v.Name == name {
+				return &v
+			}
+		}
+	} else {
+		for _, v := range vs.Variables {
+			if v.Name == "_INTERNAL_"+root+name {
+				return &v
+			}
+			if v.Name == name {
+				return &v
+			}
 		}
 	}
 
 	if vs.Outer != nil {
-		return vs.Outer.FindByName(name)
+		return vs.Outer.FindByName(name, root)
 	}
 
 	return nil
@@ -49,6 +60,8 @@ type Compiler struct {
 	scopeIndex int
 
 	variables int
+
+	root string
 }
 
 type EmittedInstruction struct {
@@ -128,10 +141,6 @@ func CreateWithState(s *SymbolTable, constants []object.Object) *Compiler {
 	return comp
 }
 
-func (c *Compiler) compileToFile(path string) {
-
-}
-
 func (c *Compiler) addConstant(obj object.Object) int {
 	c.constants = append(c.constants, obj)
 	return len(c.constants) - 1

compiler/compiler_test.go

@@ -290,7 +290,7 @@ func runCompilerTestsErrors(t *testing.T, tests []compilerTestCaseError) {
 
 		compiler := Create()
 
-		err := compiler.Compile(program)
+		err := compiler.Compile(program, "", "", "")
 
 		if err == nil && tc.expected != "" {
 			t.Fatalf("incorrect error. got=%q. expected=%q", err, tc.expected)
@@ -312,7 +312,7 @@ func runCompilerTests(t *testing.T, tests []compilerTestCase) {
 
 		compiler := Create()
 
-		err := compiler.Compile(program)
+		err := compiler.Compile(program, "", "", "")
 
 		if err != nil {
 			t.Fatalf("compiler error: %s", err)