Merge pull request #256 from yassinebenaid/dev

allow use of `break` and `continue` in nested scopes

Author: yassinebenaid

README.md

@@ -14,24 +14,28 @@
 
 A shell compiler that converts shell scripts into secure, portable and static binaries. Unlike other tools (ie. [shc](https://github.com/neurobin/shc)), Bunster does not just wrap your script within a binary. It literally compiles them to standalone shell-independent programs.
 
-Technically speaking, **Bunster** in fact is a `shell-to-Go` [Transpiler](https://en.wikipedia.org/wiki/Source-to-source_compiler) that generates [Go](https://go.dev) source out of your scripts. Then, optionally uses the [Go Toolchain](https://go.dev/dl) to compile the code to an executable.
+Under the hood, **Bunster** transpiles shell scripts into [Go](https://go.dev) code. Then uses the [Go Toolchain](https://go.dev/dl) to compile the code to an executable.
 
-**Bunster** aims to be compatible with `bash` as a starting move. You should expect your `bash` scripts to just work with bunster. Additional shells will be supported as soon as we release v1.
+**Bunster** aims to be compatible with `bash` as a starting move. Expecting that most `bash` scripts will just work with bunster. Additional shells will be supported as soon as we release v1.
 
 > [!WARNING]
 > This project is in its early stages of development. [Only a subset of features are supported so far](https://bunster.netlify.app/features/simple-commands).
 
-## Vision
+## Features
 
-Bunster has a vision to make shell scripts feel like any modern programming language. With as many features as we could, without any bloating. anything that
-makes you feel happy when writing shell scripts. a feeling that shells usually don't provide, a feeling that languages like Go give you, we aim to:
+In addition to being compatible with bash. bunster offers a lot of additional features that empower its uniqueness:
 
-- Improve error handling and messages, we want to help everyone write error-aware scripts. And when they fail, we want to give them clear, concise error messages.
-- Introduce a module system that allows you to publish and consume scripts as libraries, with a builtin package manager.
-- Add first-class support for a wide collection of builtin commands that just work out of the box. You don't need external programs to use them.
-- Add first-class support for `.env` files. Allowing you to load variables from `.env`.
-- Support static asset embedding. This feature allows you to embed a file's content to a variable at build time. ([Go has one already](https://pkg.go.dev/embed))
-- Support different shells and POSIX.
+- **Static binaries**: scripts compiled with bunster are not just wrappers around your script, nor do they rely on any external shells on your system.
+
+- **Modular**: unlike traditional shells scripts that are written in a single file. bunster offers a module system that allows you to distribute code across as many files as needed. [learn more](https://bunster.netlify.app/workspace/modules)
+
+- **Package Manager**: bunster has a buitlin package manager that makes it easy to publish and consume modules as libraries. [learn more](https://bunster.netlify.app/workspace/modules)
+
+- **Native `.env` files support**: `.env` files are nativily supported in bunster. Allowing you to load variables from `.env` files at runtime. [learn more](https://bunster.netlify.app/features/environment-files)
+
+- **Static assets embedding**: bunster allows you to embed files and directories within your compiled program at compile time. And use them as if they were normal files in the system at runtime. [learn more](https://bunster.netlify.app/features/embedding)
+
+- **Static analysis**: bunster statically analizes your scripts and reports potential bugs at compile time. (_wip_)
 
 ## Get Started
 

analyser/analyser.go

@@ -33,9 +33,10 @@ func Analyse(s ast.Script, main bool) error {
 }
 
 type analyser struct {
-	script ast.Script
-	errors []error
-	stack  []ast.Statement
+	script      ast.Script
+	errors      []error
+	stack       []ast.Statement
+	breakpoints int
 }
 
 func (a *analyser) analyse(main bool) {
@@ -73,7 +74,7 @@ func (a *analyser) analyseStatement(s ast.Statement) {
 	case ast.List:
 		a.analyseStatement(v.Left)
 		a.analyseStatement(v.Right)
-	case ast.If:
+	case *ast.If:
 		for _, s := range v.Head {
 			a.analyseStatement(s)
 		}
@@ -145,50 +146,16 @@ func (a *analyser) analyseStatement(s ast.Statement) {
 				a.analyseExpression(pa.Value)
 			}
 		}
-	case ast.Loop:
-		for _, s := range v.Head {
-			a.analyseStatement(s)
-		}
-		for _, s := range v.Body {
-			a.analyseStatement(s)
-		}
-		for _, r := range v.Redirections {
-			if r.Dst != nil {
-				a.analyseExpression(r.Dst)
-			}
-		}
-	case ast.Break:
-		var withinLoop bool
-	loop:
-		for i := len(a.stack) - 1; i >= 0; i-- {
-			switch a.stack[i].(type) {
-			case ast.Loop, ast.RangeLoop, ast.For:
-				withinLoop = true
-				break loop
-			case ast.List, ast.Break:
-			default:
-				a.report(Error{Msg: "the `break` keyword cannot be used here"})
-			}
-		}
-		if !withinLoop {
-			a.report(Error{Msg: "the `break` keyword cannot be used here"})
-		}
-	case ast.Continue:
-		var withinLoop bool
-	loop2:
-		for i := len(a.stack) - 1; i >= 0; i-- {
-			switch a.stack[i].(type) {
-			case ast.Loop, ast.RangeLoop, ast.For:
-				withinLoop = true
-				break loop2
-			case ast.List, ast.Continue:
-			default:
-				a.report(Error{Msg: "the `continue` keyword cannot be used here"})
-			}
-		}
-		if !withinLoop {
-			a.report(Error{Msg: "the `continue` keyword cannot be used here"})
-		}
+	case *ast.For:
+		a.analyseFor(v)
+	case *ast.RangeLoop:
+		a.analyseRangeLoop(v)
+	case *ast.Loop:
+		a.analyseLoop(v)
+	case *ast.Break:
+		a.analyseBreak(v)
+	case *ast.Continue:
+		a.analyseContinue(v)
 	case ast.Pipeline:
 		for _, cmd := range v {
 			a.analyseStatement(cmd.Command)
@@ -208,36 +175,7 @@ func (a *analyser) analyseStatement(s ast.Statement) {
 				a.analyseExpression(r.Dst)
 			}
 		}
-	case ast.RangeLoop:
-		for _, expr := range v.Operands {
-			a.analyseExpression(expr)
-		}
-		for _, s := range v.Body {
-			a.analyseStatement(s)
-		}
-		for _, r := range v.Redirections {
-			if r.Dst != nil {
-				a.analyseExpression(r.Dst)
-			}
-		}
-	case ast.For:
-		for _, expr := range v.Head.Init {
-			a.analyseArithmeticExpression(expr)
-		}
-		for _, expr := range v.Head.Test {
-			a.analyseArithmeticExpression(expr)
-		}
-		for _, expr := range v.Head.Update {
-			a.analyseArithmeticExpression(expr)
-		}
-		for _, s := range v.Body {
-			a.analyseStatement(s)
-		}
-		for _, r := range v.Redirections {
-			if r.Dst != nil {
-				a.analyseExpression(r.Dst)
-			}
-		}
+
 	case ast.Test:
 		a.analyseExpression(v.Expr)
 
@@ -267,7 +205,7 @@ func (a *analyser) analyseStatement(s ast.Statement) {
 				a.analyseExpression(r.Dst)
 			}
 		}
-	case ast.Case:
+	case *ast.Case:
 		a.analyseExpression(v.Word)
 
 		for _, _case := range v.Cases {

analyser/loops.go

@@ -0,0 +1,153 @@
+package analyser
+
+import (
+	"github.com/yassinebenaid/bunster/ast"
+)
+
+func (a *analyser) analyseFor(loop *ast.For) {
+	for _, expr := range loop.Head.Init {
+		a.analyseArithmeticExpression(expr)
+	}
+	for _, expr := range loop.Head.Test {
+		a.analyseArithmeticExpression(expr)
+	}
+	for _, expr := range loop.Head.Update {
+		a.analyseArithmeticExpression(expr)
+	}
+	for _, s := range loop.Body {
+		a.analyseStatement(s)
+	}
+	for _, r := range loop.Redirections {
+		if r.Dst != nil {
+			a.analyseExpression(r.Dst)
+		}
+	}
+}
+
+func (a *analyser) analyseRangeLoop(loop *ast.RangeLoop) {
+	for _, expr := range loop.Operands {
+		a.analyseExpression(expr)
+	}
+	for _, s := range loop.Body {
+		a.analyseStatement(s)
+	}
+	for _, r := range loop.Redirections {
+		if r.Dst != nil {
+			a.analyseExpression(r.Dst)
+		}
+	}
+}
+
+func (a *analyser) analyseLoop(loop *ast.Loop) {
+	for _, s := range loop.Head {
+		a.analyseStatement(s)
+	}
+	for _, s := range loop.Body {
+		a.analyseStatement(s)
+	}
+	for _, r := range loop.Redirections {
+		if r.Dst != nil {
+			a.analyseExpression(r.Dst)
+		}
+	}
+}
+
+func (a *analyser) analyseBreak(b *ast.Break) {
+	a.breakpoints++
+	b.BreakPoint = a.breakpoints
+
+	var withinLoop bool
+	var last int
+
+loop:
+	for i := len(a.stack) - 1; i >= 0; i-- {
+		switch v := a.stack[i].(type) {
+		case *ast.Loop:
+			v.BreakPoints.Add(a.breakpoints, ast.DECLARE)
+			withinLoop = true
+			break loop
+		case *ast.RangeLoop:
+			v.BreakPoints.Add(a.breakpoints, ast.DECLARE)
+			withinLoop = true
+			break loop
+		case *ast.For:
+			v.BreakPoints.Add(a.breakpoints, ast.DECLARE)
+			withinLoop = true
+			break loop
+		case *ast.If:
+			v.BreakPoints.Add(a.breakpoints, ast.RETURN)
+		case *ast.Case:
+			v.BreakPoints.Add(a.breakpoints, ast.RETURN)
+		case *ast.Break:
+			v.Type = ast.RETURN
+		case ast.List:
+		default:
+			break loop
+		}
+		last = i
+	}
+
+	if !withinLoop {
+		a.report(Error{Msg: "the `break` keyword cannot be used here"})
+		return
+	}
+
+	switch v := a.stack[last].(type) {
+	case *ast.If:
+		v.BreakPoints.Add(a.breakpoints, ast.BREAK)
+	case *ast.Case:
+		v.BreakPoints.Add(a.breakpoints, ast.BREAK)
+	case *ast.Break, ast.List:
+		b.Type = ast.CONTINUE
+	}
+}
+
+func (a *analyser) analyseContinue(b *ast.Continue) {
+	a.breakpoints++
+	b.BreakPoint = a.breakpoints
+
+	var withinLoop bool
+	var last int
+
+loop:
+	for i := len(a.stack) - 1; i >= 0; i-- {
+		switch v := a.stack[i].(type) {
+		case *ast.Loop:
+			v.BreakPoints.Add(a.breakpoints, ast.DECLARE)
+			withinLoop = true
+			break loop
+		case *ast.RangeLoop:
+			v.BreakPoints.Add(a.breakpoints, ast.DECLARE)
+			withinLoop = true
+			break loop
+		case *ast.For:
+			v.BreakPoints.Add(a.breakpoints, ast.DECLARE)
+			withinLoop = true
+			break loop
+		case *ast.If:
+			v.BreakPoints.Add(a.breakpoints, ast.RETURN)
+		case *ast.Case:
+			v.BreakPoints.Add(a.breakpoints, ast.RETURN)
+		case *ast.Continue:
+			v.Type = ast.RETURN
+		case ast.List:
+		default:
+			break loop
+		}
+		last = i
+	}
+
+	if !withinLoop {
+		a.report(Error{Msg: "the `continue` keyword cannot be used here"})
+		return
+	}
+
+	switch v := a.stack[last].(type) {
+	case *ast.If:
+		v.BreakPoints.Add(a.breakpoints, ast.CONTINUE)
+	case *ast.Case:
+		v.BreakPoints.Add(a.breakpoints, ast.CONTINUE)
+	case *ast.Continue, ast.List:
+		b.Type = ast.CONTINUE
+	}
+}