just-bash 0.1.5__py3-none-any.whl

just_bash/interpreter/control_flow.py

@@ -0,0 +1,381 @@
+"""Control Flow Execution.
+
+Handles control flow constructs:
+- if/elif/else
+- for loops
+- C-style for loops
+- while loops
+- until loops
+- case statements
+- break/continue
+"""
+
+from typing import TYPE_CHECKING
+
+from ..ast.types import (
+    IfNode,
+    ForNode,
+    CStyleForNode,
+    WhileNode,
+    UntilNode,
+    CaseNode,
+)
+from ..types import ExecResult
+from .errors import BreakError, ContinueError, ExecutionLimitError
+from .expansion import expand_word_async, expand_word_with_glob, evaluate_arithmetic
+
+if TYPE_CHECKING:
+    from .types import InterpreterContext
+
+
+def _result(stdout: str, stderr: str, exit_code: int) -> ExecResult:
+    """Create an ExecResult."""
+    return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)
+
+
+def _failure(stderr: str) -> ExecResult:
+    """Create a failed result."""
+    return ExecResult(stdout="", stderr=stderr, exit_code=1)
+
+
+async def execute_if(ctx: "InterpreterContext", node: IfNode) -> ExecResult:
+    """Execute an if statement."""
+    stdout = ""
+    stderr = ""
+
+    for clause in node.clauses:
+        # Execute condition
+        cond_result = await execute_condition(ctx, clause.condition)
+        stdout += cond_result.stdout
+        stderr += cond_result.stderr
+
+        if cond_result.exit_code == 0:
+            # Condition is true - execute body
+            return await execute_statements(ctx, clause.body, stdout, stderr)
+
+    # No condition matched - check for else
+    if node.else_body:
+        return await execute_statements(ctx, node.else_body, stdout, stderr)
+
+    return _result(stdout, stderr, 0)
+
+
+async def execute_for(ctx: "InterpreterContext", node: ForNode) -> ExecResult:
+    """Execute a for loop."""
+    stdout = ""
+    stderr = ""
+    exit_code = 0
+    iterations = 0
+
+    # Validate variable name
+    import re
+    if not re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', node.variable):
+        return _failure(f"bash: `{node.variable}': not a valid identifier\n")
+
+    # Get words to iterate over
+    words: list[str] = []
+    if node.words is None:
+        # Iterate over positional parameters
+        params = ctx.state.env.get("@", "").split()
+        words = [p for p in params if p]
+    elif len(node.words) == 0:
+        words = []
+    else:
+        for word in node.words:
+            expanded = await expand_word_with_glob(ctx, word)
+            words.extend(expanded["values"])
+
+    ctx.state.loop_depth += 1
+    try:
+        for value in words:
+            iterations += 1
+            if iterations > ctx.limits.max_loop_iterations:
+                raise ExecutionLimitError(
+                    f"for loop: too many iterations ({ctx.limits.max_loop_iterations})",
+                    "iterations",
+                )
+
+            ctx.state.env[node.variable] = value
+
+            try:
+                for stmt in node.body:
+                    result = await ctx.execute_statement(stmt)
+                    stdout += result.stdout
+                    stderr += result.stderr
+                    exit_code = result.exit_code
+            except BreakError as e:
+                stdout += e.stdout
+                stderr += e.stderr
+                if e.levels > 1 and ctx.state.loop_depth > 1:
+                    e.levels -= 1
+                    e.stdout = stdout
+                    e.stderr = stderr
+                    raise
+                break
+            except ContinueError as e:
+                stdout += e.stdout
+                stderr += e.stderr
+                if e.levels > 1 and ctx.state.loop_depth > 1:
+                    e.levels -= 1
+                    e.stdout = stdout
+                    e.stderr = stderr
+                    raise
+                continue
+    finally:
+        ctx.state.loop_depth -= 1
+
+    return _result(stdout, stderr, exit_code)
+
+
+async def execute_c_style_for(ctx: "InterpreterContext", node: CStyleForNode) -> ExecResult:
+    """Execute a C-style for loop: for ((init; cond; update))."""
+    stdout = ""
+    stderr = ""
+    exit_code = 0
+    iterations = 0
+
+    # Execute init
+    if node.init:
+        await evaluate_arithmetic(ctx, node.init.expression)
+
+    ctx.state.loop_depth += 1
+    try:
+        while True:
+            iterations += 1
+            if iterations > ctx.limits.max_loop_iterations:
+                raise ExecutionLimitError(
+                    f"for loop: too many iterations ({ctx.limits.max_loop_iterations})",
+                    "iterations",
+                )
+
+            # Check condition
+            if node.condition:
+                cond_result = await evaluate_arithmetic(ctx, node.condition.expression)
+                if cond_result == 0:
+                    break
+
+            try:
+                for stmt in node.body:
+                    result = await ctx.execute_statement(stmt)
+                    stdout += result.stdout
+                    stderr += result.stderr
+                    exit_code = result.exit_code
+            except BreakError as e:
+                stdout += e.stdout
+                stderr += e.stderr
+                if e.levels > 1 and ctx.state.loop_depth > 1:
+                    e.levels -= 1
+                    raise
+                break
+            except ContinueError as e:
+                stdout += e.stdout
+                stderr += e.stderr
+                if e.levels > 1 and ctx.state.loop_depth > 1:
+                    e.levels -= 1
+                    raise
+                # Still run update on continue
+                if node.update:
+                    await evaluate_arithmetic(ctx, node.update.expression)
+                continue
+
+            # Execute update
+            if node.update:
+                await evaluate_arithmetic(ctx, node.update.expression)
+    finally:
+        ctx.state.loop_depth -= 1
+
+    return _result(stdout, stderr, exit_code)
+
+
+async def execute_while(ctx: "InterpreterContext", node: WhileNode, stdin: str = "") -> ExecResult:
+    """Execute a while loop."""
+    stdout = ""
+    stderr = ""
+    exit_code = 0
+    iterations = 0
+
+    ctx.state.loop_depth += 1
+    try:
+        while True:
+            iterations += 1
+            if iterations > ctx.limits.max_loop_iterations:
+                raise ExecutionLimitError(
+                    f"while loop: too many iterations ({ctx.limits.max_loop_iterations})",
+                    "iterations",
+                )
+
+            # Execute condition
+            saved_in_condition = ctx.state.in_condition
+            ctx.state.in_condition = True
+            try:
+                cond_result = await execute_condition(ctx, node.condition)
+                stdout += cond_result.stdout
+                stderr += cond_result.stderr
+
+                if cond_result.exit_code != 0:
+                    break
+            finally:
+                ctx.state.in_condition = saved_in_condition
+
+            try:
+                for stmt in node.body:
+                    result = await ctx.execute_statement(stmt)
+                    stdout += result.stdout
+                    stderr += result.stderr
+                    exit_code = result.exit_code
+            except BreakError as e:
+                stdout += e.stdout
+                stderr += e.stderr
+                if e.levels > 1 and ctx.state.loop_depth > 1:
+                    e.levels -= 1
+                    raise
+                break
+            except ContinueError as e:
+                stdout += e.stdout
+                stderr += e.stderr
+                if e.levels > 1 and ctx.state.loop_depth > 1:
+                    e.levels -= 1
+                    raise
+                continue
+    finally:
+        ctx.state.loop_depth -= 1
+
+    return _result(stdout, stderr, exit_code)
+
+
+async def execute_until(ctx: "InterpreterContext", node: UntilNode) -> ExecResult:
+    """Execute an until loop."""
+    stdout = ""
+    stderr = ""
+    exit_code = 0
+    iterations = 0
+
+    ctx.state.loop_depth += 1
+    try:
+        while True:
+            iterations += 1
+            if iterations > ctx.limits.max_loop_iterations:
+                raise ExecutionLimitError(
+                    f"until loop: too many iterations ({ctx.limits.max_loop_iterations})",
+                    "iterations",
+                )
+
+            # Execute condition (until exits when condition is TRUE)
+            saved_in_condition = ctx.state.in_condition
+            ctx.state.in_condition = True
+            try:
+                cond_result = await execute_condition(ctx, node.condition)
+                stdout += cond_result.stdout
+                stderr += cond_result.stderr
+
+                if cond_result.exit_code == 0:
+                    break  # Condition became true, exit loop
+            finally:
+                ctx.state.in_condition = saved_in_condition
+
+            try:
+                for stmt in node.body:
+                    result = await ctx.execute_statement(stmt)
+                    stdout += result.stdout
+                    stderr += result.stderr
+                    exit_code = result.exit_code
+            except BreakError as e:
+                stdout += e.stdout
+                stderr += e.stderr
+                if e.levels > 1 and ctx.state.loop_depth > 1:
+                    e.levels -= 1
+                    raise
+                break
+            except ContinueError as e:
+                stdout += e.stdout
+                stderr += e.stderr
+                if e.levels > 1 and ctx.state.loop_depth > 1:
+                    e.levels -= 1
+                    raise
+                continue
+    finally:
+        ctx.state.loop_depth -= 1
+
+    return _result(stdout, stderr, exit_code)
+
+
+async def execute_case(ctx: "InterpreterContext", node: CaseNode) -> ExecResult:
+    """Execute a case statement."""
+    import fnmatch
+
+    stdout = ""
+    stderr = ""
+    exit_code = 0
+
+    # Expand the word to match against
+    word_value = await expand_word_async(ctx, node.word)
+
+    for case_item in node.items:
+        # Check each pattern
+        matched = False
+        for pattern in case_item.patterns:
+            pattern_value = await expand_word_async(ctx, pattern)
+            if fnmatch.fnmatch(word_value, pattern_value):
+                matched = True
+                break
+
+        if matched:
+            # Execute the body for this case
+            for stmt in case_item.body:
+                result = await ctx.execute_statement(stmt)
+                stdout += result.stdout
+                stderr += result.stderr
+                exit_code = result.exit_code
+
+            # Check terminator
+            if case_item.terminator == ";;":
+                # Normal termination - exit case
+                break
+            elif case_item.terminator == ";&":
+                # Fall through to next case body (without pattern check)
+                continue
+            elif case_item.terminator == ";;&":
+                # Continue checking patterns
+                continue
+            else:
+                break
+
+    return _result(stdout, stderr, exit_code)
+
+
+async def execute_condition(ctx: "InterpreterContext", condition: list) -> ExecResult:
+    """Execute a condition (list of statements) and return the result."""
+    stdout = ""
+    stderr = ""
+    exit_code = 0
+
+    saved_in_condition = ctx.state.in_condition
+    ctx.state.in_condition = True
+    try:
+        for stmt in condition:
+            result = await ctx.execute_statement(stmt)
+            stdout += result.stdout
+            stderr += result.stderr
+            exit_code = result.exit_code
+    finally:
+        ctx.state.in_condition = saved_in_condition
+
+    return _result(stdout, stderr, exit_code)
+
+
+async def execute_statements(
+    ctx: "InterpreterContext",
+    statements: list,
+    stdout: str = "",
+    stderr: str = "",
+) -> ExecResult:
+    """Execute a list of statements."""
+    exit_code = 0
+
+    for stmt in statements:
+        result = await ctx.execute_statement(stmt)
+        stdout += result.stdout
+        stderr += result.stderr
+        exit_code = result.exit_code
+
+    return _result(stdout, stderr, exit_code)

just_bash/interpreter/errors.py

@@ -0,0 +1,116 @@
+"""Interpreter errors for just-bash."""
+
+
+class InterpreterError(Exception):
+    """Base class for interpreter errors."""
+
+    def __init__(self, message: str = ""):
+        super().__init__(message)
+        self.stdout = ""
+        self.stderr = ""
+
+    def prepend_output(self, stdout: str, stderr: str) -> None:
+        """Prepend accumulated output to error output."""
+        self.stdout = stdout + self.stdout
+        self.stderr = stderr + self.stderr
+
+
+class ExitError(InterpreterError):
+    """Raised when 'exit' builtin is called."""
+
+    def __init__(self, exit_code: int, stdout: str = "", stderr: str = ""):
+        super().__init__(f"exit {exit_code}")
+        self.exit_code = exit_code
+        self.stdout = stdout
+        self.stderr = stderr
+
+
+class ReturnError(InterpreterError):
+    """Raised when 'return' builtin is called."""
+
+    def __init__(self, exit_code: int, stdout: str = "", stderr: str = ""):
+        super().__init__(f"return {exit_code}")
+        self.exit_code = exit_code
+        self.stdout = stdout
+        self.stderr = stderr
+
+
+class BreakError(InterpreterError):
+    """Raised when 'break' builtin is called."""
+
+    def __init__(self, levels: int = 1, stdout: str = "", stderr: str = ""):
+        super().__init__(f"break {levels}")
+        self.levels = levels
+        self.stdout = stdout
+        self.stderr = stderr
+
+
+class ContinueError(InterpreterError):
+    """Raised when 'continue' builtin is called."""
+
+    def __init__(self, levels: int = 1, stdout: str = "", stderr: str = ""):
+        super().__init__(f"continue {levels}")
+        self.levels = levels
+        self.stdout = stdout
+        self.stderr = stderr
+
+
+class ErrexitError(InterpreterError):
+    """Raised when errexit (set -e) terminates execution."""
+
+    def __init__(self, exit_code: int, stdout: str = "", stderr: str = ""):
+        super().__init__(f"errexit with code {exit_code}")
+        self.exit_code = exit_code
+        self.stdout = stdout
+        self.stderr = stderr
+
+
+class NounsetError(InterpreterError):
+    """Raised when nounset (set -u) encounters unset variable."""
+
+    def __init__(self, variable: str, stdout: str = "", stderr: str = ""):
+        super().__init__(f"unbound variable: {variable}")
+        self.variable = variable
+        self.stdout = stdout
+        self.stderr = stderr
+
+
+class BadSubstitutionError(InterpreterError):
+    """Raised for bad parameter substitution."""
+
+    def __init__(self, message: str, stdout: str = "", stderr: str = ""):
+        super().__init__(message)
+        self.stdout = stdout
+        self.stderr = stderr
+
+
+class ArithmeticError(InterpreterError):
+    """Raised for arithmetic evaluation errors."""
+
+    def __init__(self, message: str, stdout: str = "", stderr: str = ""):
+        super().__init__(message)
+        self.stdout = stdout
+        self.stderr = stderr
+
+
+class ExecutionLimitError(InterpreterError):
+    """Raised when execution limits are exceeded."""
+
+    def __init__(self, message: str, limit_type: str):
+        super().__init__(message)
+        self.limit_type = limit_type
+
+
+class SubshellExitError(InterpreterError):
+    """Raised when a subshell exits."""
+
+    def __init__(self, exit_code: int, stdout: str = "", stderr: str = ""):
+        super().__init__(f"subshell exit {exit_code}")
+        self.exit_code = exit_code
+        self.stdout = stdout
+        self.stderr = stderr
+
+
+def is_scope_exit_error(error: Exception) -> bool:
+    """Check if an error should exit the current scope."""
+    return isinstance(error, (ExitError, ReturnError, BreakError, ContinueError))