File Coverage

lib/BATsh.pm

Criterion	Covered	Total	%
statement	310	387	80.1
branch	150	222	67.5
condition	37	62	59.6
subroutine	26	33	78.7
pod	0	12	0.0
total	523	716	73.0

package BATsh;
######################################################################
#
# BATsh - Bilingual Shell for cmd.exe and bash in one script
#
# https://metacpan.org/dist/BATsh
#
# Copyright (c) 2026 INABA Hitoshi
#
# This version implements both cmd.exe and sh/bash command sets
# entirely in Perl.  No external cmd.exe, bash, or sh is required.
#
######################################################################

use 5.00503;
use strict;
BEGIN { if ($] < 5.006 && !defined(&warnings::import)) { $INC{'warnings.pm'} = 'stub'; eval 'package warnings; sub import {}' } }
use warnings; local $^W = 1;
BEGIN { pop @INC if $INC[-1] eq '.' }

use File::Spec ();
BEGIN { eval { require Cwd } }
use Carp qw(croak);
use vars qw($VERSION);
$VERSION = '0.06';
$VERSION = $VERSION;

require BATsh::Env;
require BATsh::CMD;
require BATsh::SH;

###############################################################################
# Architecture
###############################################################################
#
# BATsh is a bilingual shell interpreter.
#
# It splits a script into CMD sections and SH sections, then executes
# each section using its own pure-Perl interpreter:
#
#   BATsh::CMD  -- cmd.exe command set (SET, ECHO, IF, FOR, GOTO, ...)
#   BATsh::SH   -- sh/bash command set (echo, export, if/fi, for/done, ...)
#   BATsh::Env  -- shared variable store (bridge between both modes)
#
# MODE DETECTION: first non-empty, non-comment token of each section.
#   CMD: token is [A-Z 0-9 _ - \ / : . @ %]+ with at least one A-Z
#   SH:  anything else
#
# SECTION BOUNDARY:
#   CMD: parenthesis ( ) depth returns to 0
#   SH:  keyword depth (if/fi, for/done, ...) returns to 0
#
# ENV BRIDGE:
#   BATsh::Env::STORE is the single variable table.
#   CMD %VAR% and SH $VAR both read/write the same store.
#
###############################################################################

###############################################################################
# Global state
###############################################################################
my $_TMPCOUNT = 0;

# Subroutine registry: { LABEL => \@lines }
my %_SUBROUTINES = ();

###############################################################################
# Constructor
###############################################################################
sub new {
    my ($class, %args) = @_;
    BATsh::Env::init();
    return bless { verbose => $args{verbose} || 0 }, $class;
}

###############################################################################
# Public run interface
###############################################################################
sub run {
    my ($class_or_self, $file, %args) = @_;
    unless (-f $file) { croak "BATsh->run: file not found: $file" }
    local *SRCFH;
    open(SRCFH, $file) or croak "BATsh->run: cannot open $file: $!";
    my @lines = ;
    close(SRCFH);
    _ensure_env_init();
    # Set batch positional parameters: %0 = script path, %1..%9 = args, %* = all args
    my @script_args = defined($args{args}) ? @{$args{args}} : ();
    _set_batch_args($file, @script_args);
    _process_lines(@lines);
    BATsh::SH::fire_exit_trap("BATsh::SH") if defined &BATsh::SH::fire_exit_trap;
    return 1;
}

sub run_string {
    my ($class_or_self, $source) = @_;
    croak "BATsh->run_string: source required" unless defined $source;
    my @lines = map { "$_\n" } split(/\n/, $source, -1);
    _ensure_env_init();
    _process_lines(@lines);
    BATsh::SH::fire_exit_trap("BATsh::SH") if defined &BATsh::SH::fire_exit_trap;
    return 1;
}

sub run_lines {
    my ($class_or_self, @lines) = @_;
    _ensure_env_init();
    _process_lines(@lines);
    BATsh::SH::fire_exit_trap("BATsh::SH") if defined &BATsh::SH::fire_exit_trap;
    return 1;
}

sub _ensure_env_init {
    # Init only once per process
    BATsh::Env::init() unless %BATsh::Env::STORE;
}

###############################################################################
# _set_batch_args -- populate %0..%9 and %* in the Env store
#   %0  = script path (as passed to run())
#   %1  = first argument, ..., %9 = ninth argument
#   %*  = all arguments joined by single space (does not include %0)
###############################################################################
sub _set_batch_args {
    my ($script, @args) = @_;
    # Normalise $0: resolve to absolute path using File::Spec
    my $abs_script = defined $script ? $script : '';
    if ($abs_script ne '' && !File::Spec->file_name_is_absolute($abs_script)) {
        my $cwd = defined(&Cwd::cwd) ? Cwd::cwd() : '.';
        $abs_script = File::Spec->catfile($cwd, $abs_script);
    }
    BATsh::Env->set('%0', $abs_script);
    for my $n (1 .. 9) {
        BATsh::Env->set("%$n", defined($args[$n - 1]) ? $args[$n - 1] : '');
    }
    BATsh::Env->set('%*', join(' ', @args));
}

###############################################################################
# classify_token
###############################################################################
sub classify_token {
    my ($class_or_token, $token) = @_;
    unless (defined $token) { $token = $class_or_token }
    if ($token =~ /\A[A-Z0-9_\-\\\/\.:@%]+\z/ && $token =~ /[A-Z]/) {
        return 'CMD';
    }
    return 'SH';
}

###############################################################################
# Line parser
# Returns ($mode, $stripped_line, $first_token)
###############################################################################
sub _parse_line {
    my ($line) = @_;
    (my $s = $line) =~ s/\r?\n\z//;
    return ('EMPTY', $s, '')   if $s =~ /\A\s*\z/;
    return ('COMMENT', $s, '') if $s =~ /\A\s*(?:::|\@?REM(?:\s|\z))/i;
    return ('COMMENT', $s, '') if $s =~ /\A\s*#(?!!)/;
    (my $t = $s) =~ s/\A\s+//;
    my $first = ($t =~ /\A(\S+)/) ? $1 : '';
    return (classify_token($first), $s, $first);
}

###############################################################################
# CMD section depth: count unquoted ( )
###############################################################################
sub _cmd_paren_delta {
    my ($line) = @_;
    my ($delta, $in_q) = (0, 0);
    for my $ch (split //, $line) {
        if ($ch eq '"')     { $in_q = !$in_q }
        elsif (!$in_q) {
            $delta++ if $ch eq '(';
            $delta-- if $ch eq ')';
        }
    }
    return $delta;
}

###############################################################################
# SH section depth
###############################################################################
my %_SH_OPEN  = map { $_ => 1 } qw(if for while until case function select);
my %_SH_CLOSE = map { $_ => 1 } qw(fi done esac);

# Net SH block-depth change for an ENTIRE line.
#
# A single physical line may both open and close a block, e.g.
#   for i in 1 2 3; do echo $i; done      (net 0)
#   while COND; do ...; done; done         (net -1, nested close)
# Looking only at the first token (as earlier versions did) counted the
# leading "for"/"while" but never the inline "done", so the SH section was
# left open and a following CMD line (e.g. ECHO ...%VAR%...) was wrongly
# absorbed into the SH section and run by the SH interpreter.
#
# Opener keywords (if for while until case function select) and "{" add 1;
# closer keywords (fi done esac) and "}" subtract 1, but only when they are in
# command position (line start, or just after ; & | ( ) { } or do/then/else/
# elif).  Single- and double-quoted text, $( ... ) command substitutions and
# `...` backticks are skipped so that a "done" inside a string or substitution
# does not affect the depth.  Perl 5.005_03 compatible (no regex features
# beyond character classes; substr/index style scanning).
sub _sh_depth_delta {
    my ($line) = @_;
    return 0 unless defined $line;

    # Fast path: a bare single keyword token (the common multi-line case).
    if ($line !~ /[\s;&|(){}'"`]/) {
        my $l = lc($line);
        return  1 if exists $_SH_OPEN{$l};
        return -1 if exists $_SH_CLOSE{$l};
        return  0;
    }

    my $delta  = 0;
    my $cmdpos = 1;            # next bareword starts a new statement?
    my $i      = 0;
    my $n      = length($line);
    while ($i < $n) {
        my $c = substr($line, $i, 1);

        if ($c eq "'") {                      # single-quoted region
            $i++;
            $i++ while $i < $n && substr($line, $i, 1) ne "'";
            $i++; $cmdpos = 0; next;
        }
        if ($c eq '"') {                      # double-quoted region
            $i++;
            while ($i < $n && substr($line, $i, 1) ne '"') {
                if (substr($line, $i, 1) eq '\\') { $i += 2; next }
                $i++;
            }
            $i++; $cmdpos = 0; next;
        }
        if ($c eq '`') {                      # backtick substitution
            $i++;
            $i++ while $i < $n && substr($line, $i, 1) ne '`';
            $i++; $cmdpos = 0; next;
        }
        if ($c eq '$' && $i + 1 < $n && substr($line, $i + 1, 1) eq '(') {
            $i += 2;                          # $( ... ) -- skip balanced parens
            my $d = 1;
            while ($i < $n && $d > 0) {
                my $ch = substr($line, $i, 1);
                $d++ if $ch eq '(';
                $d-- if $ch eq ')';
                $i++;
            }
            $cmdpos = 0; next;
        }
        if ($c =~ /\s/)                 { $i++; next }
        if ($c eq ';' || $c eq '&' || $c eq '|') { $cmdpos = 1; $i++; next }
        if ($c eq '(')                 { $cmdpos = 1; $i++; next }
        if ($c eq ')')                 { $cmdpos = 1; $i++; next }
        if ($c eq '{') { $delta++ if $cmdpos; $cmdpos = 1; $i++; next }
        if ($c eq '}') { $delta-- if $cmdpos; $cmdpos = 1; $i++; next }

        # Bareword
        my $word = '';
        while ($i < $n) {
            my $wc = substr($line, $i, 1);
            last if $wc =~ /[\s;&|(){}'"`]/;
            $word .= $wc; $i++;
        }
        if ($cmdpos) {
            my $lw = lc($word);
            if    (exists $_SH_OPEN{$lw})  { $delta++ }
            elsif (exists $_SH_CLOSE{$lw}) { $delta-- }
            # do/then/else/elif keep the FOLLOWING word in command position so
            # that an opener directly after them (e.g. "do for ...") is counted.
            $cmdpos = ($lw eq 'do' || $lw eq 'then'
                    || $lw eq 'else' || $lw eq 'elif') ? 1 : 0;
        }
        else {
            $cmdpos = 0;
        }
    }
    return $delta;
}

###############################################################################
# Subroutine extraction
###############################################################################
sub _extract_subroutines {
    my (@lines) = @_;
    my @out = (); my $in_sub = ''; my @sub_body = ();

    # Determine which :LABEL lines are subroutine ENTRY points (to be lifted
    # out of the main stream and stored in %_SUBROUTINES) versus ordinary
    # GOTO labels (which stay in the stream for the CMD interpreter).
    #
    # Two independent signals are unioned:
    #
    #   (a) CALL targets: any label named by a "CALL :LABEL" anywhere in the
    #       script is an entry point.  This is the decisive signal -- a label
    #       you CALL is a subroutine -- and it lets a subroutine contain its
    #       own internal GOTO labels without being mis-split.
    #
    #   (b) The RET heuristic: a label whose block ends in RET/RETURN before
    #       the next label.  Kept for backward compatibility so a subroutine
    #       invoked only indirectly is still recognised.
    #
    # A label is opened as a subroutine ONLY at the top level (not while
    # already inside a subroutine body); once inside a body, every :LABEL is
    # an internal label that travels with the body so that GOTO within the
    # subroutine resolves, and only RET/RETURN closes the body.
    my %is_sub_label = ();

    # (a) CALL targets (matched anywhere on the line, e.g. "IF .. CALL :X").
    for my $line (@lines) {
        (my $s = $line) =~ s/\r?\n\z//;
        while ($s =~ /\bCALL\s+:([A-Za-z_][A-Za-z0-9_]*)/ig) {
            $is_sub_label{uc($1)} = 1;
        }
    }

    # (b) RET heuristic.
    {
        my $cur = '';
        for my $line (@lines) {
            (my $s = $line) =~ s/\r?\n\z//;
            $s =~ s/\A\s+//;
            if ($s =~ /\A:([A-Za-z_][A-Za-z0-9_]*)\s*\z/) {
                $cur = uc($1);
            }
            elsif ($cur ne '' && $s =~ /\A(?:RET|RETURN)\s*\z/i) {
                $is_sub_label{$cur} = 1;
                $cur = '';
            }
            elsif ($cur ne '' && $s =~ /\A:([A-Za-z_][A-Za-z0-9_]*)\s*\z/) {
                # New label before RET: previous one is a GOTO label, not sub
                $cur = uc($1);
            }
        }
    }

    for my $line (@lines) {
        (my $s = $line) =~ s/\r?\n\z//;
        $s =~ s/\A\s+//;
        if ($s =~ /\A:([A-Za-z_][A-Za-z0-9_]*)\s*\z/) {
            my $lbl = uc($1);
            if ($in_sub ne '') {
                # Inside a subroutine: this is an internal label of the body
                # (a GOTO target), not a new subroutine.  Keep it with the
                # body so the CMD interpreter can resolve GOTO :internal.
                push @sub_body, $line;
                next;
            }
            if ($is_sub_label{$lbl}) {
                # Top-level subroutine entry: lift it out of the main stream.
                $in_sub = $lbl; @sub_body = ();
                next;   # remove the entry-label line from the stream
            }
            # Top-level GOTO label: keep in stream for the CMD interpreter.
            push @out, $line;
            next;
        }
        if ($in_sub ne '') {
            if ($s =~ /\A(?:RET|RETURN)\s*\z/i) {
                $_SUBROUTINES{$in_sub} = [@sub_body];
                $in_sub = ''; @sub_body = ();
            }
            else {
                push @sub_body, $line;
            }
            next;
        }
        push @out, $line;
    }
    $_SUBROUTINES{$in_sub} = [@sub_body] if $in_sub ne '';
    return @out;
}

###############################################################################
# call_sub / source_file
###############################################################################
sub call_sub {
    my ($class_or_self, $label, @args) = @_;
    $label = uc($label); $label =~ s/^://;
    croak "BATsh->call_sub: undefined subroutine :$label"
        unless exists $_SUBROUTINES{$label};

    # --- Save the caller's positional-parameter frame -----------------
    # CALL :label is a true subroutine call: the callee gets its own
    # %0..%9 / %* (and the SH-side BATSH_ARG* mirror), and the caller's
    # parameters are restored on return.  An undef snapshot means the key
    # was absent and must be removed again on restore.
    my @frame_keys = ('%0','%1','%2','%3','%4','%5','%6','%7','%8','%9','%*',
                      'BATSH_ARGC',
                      'BATSH_ARG1','BATSH_ARG2','BATSH_ARG3','BATSH_ARG4',
                      'BATSH_ARG5','BATSH_ARG6','BATSH_ARG7','BATSH_ARG8',
                      'BATSH_ARG9');
    my %saved;
    for my $k (@frame_keys) {
        $saved{$k} = exists $BATsh::Env::STORE{$k} ? $BATsh::Env::STORE{$k}
                                                   : undef;
    }

    # --- Install the subroutine's own arguments -----------------------
    # %0 is the label token (":LABEL"), matching cmd.exe, so that %~..0
    # modifiers and %0 inside the subroutine refer to the label, not the
    # outer script.  %1..%9 are the call arguments; %* is their join.
    BATsh::Env->set('%0', ":$label");
    for my $n (1 .. 9) {
        BATsh::Env->set("%$n", defined($args[$n-1]) ? $args[$n-1] : '');
    }
    BATsh::Env->set('%*', join(' ', @args));

    # SH-side mirror so a subroutine body written in SH mode still sees
    # $1..$9 / $@.  Keys beyond the supplied argument count are removed so
    # a shorter call does not inherit the caller's stale BATSH_ARG* values.
    $BATsh::Env::STORE{'BATSH_ARGC'} = scalar @args;
    for my $n (1 .. 9) {
        if ($n <= scalar @args) {
            $BATsh::Env::STORE{"BATSH_ARG$n"} = $args[$n-1];
        }
        else {
            delete $BATsh::Env::STORE{"BATSH_ARG$n"};
        }
    }

    # --- Run the body, then always restore the caller frame -----------
    my $ok  = eval { _process_lines(@{$_SUBROUTINES{$label}}); 1 };
    my $err = $@;
    for my $k (@frame_keys) {
        if (defined $saved{$k}) { $BATsh::Env::STORE{$k} = $saved{$k} }
        else                    { delete $BATsh::Env::STORE{$k} }
    }
    die $err unless $ok;
    return 1;
}

sub source_file {
    my ($class_or_self, $file) = @_;
    croak "BATsh->source_file: file not found: $file" unless -f $file;
    local *SFHH;
    open(SFHH, $file) or croak "BATsh->source_file: cannot open $file: $!";
    my @src = ;
    close(SFHH);
    _process_lines(@src);
    return 1;
}

###############################################################################
# SETLOCAL / ENDLOCAL  (public API)
###############################################################################
sub setlocal  { BATsh::Env::setlocal()  }
sub endlocal  { BATsh::Env::endlocal()  }

###############################################################################
# _exec_cmd_section -- run CMD lines through BATsh::CMD
###############################################################################
sub _exec_cmd_section {
    my (@lines) = @_;
    # Handle BATsh-native directives before CMD interpreter
    my @batch = ();
    for my $line (@lines) {
        (my $s = $line) =~ s/\r?\n\z//;
        $s =~ s/\A\s+//;
        if ($s =~ /\ASETLOCAL(?:\s+(.*))?\z/i) {
            my $opts = defined $1 ? $1 : '';
            # Pass the whole line through to CMD interpreter so it sees
            # ENABLEDELAYEDEXPANSION etc; also update Env flags here.
            push @batch, $line;
            next;
        }
        if ($s =~ /\AENDLOCAL\s*\z/i) {
            # Handled inside CMD.pm / _dispatch
            push @batch, $line;
            next;
        }
        # NOTE: CALL :label and CALL file.batsh are intentionally NOT
        # intercepted here.  They are handled by the CMD interpreter's
        # _cmd_call (which delegates to call_sub / source_file).  Letting
        # CALL stay inside the batch keeps the whole CMD section in one
        # exec_block, so a GOTO whose loop body contains a CALL still finds
        # its label, and a subroutine body may use its own internal labels.
        push @batch, $line;
    }
    _flush_cmd(\@batch) if @batch;
}

sub _flush_cmd {
    my ($lines_ref) = @_;
    return unless @{$lines_ref};
    BATsh::CMD::exec_block('BATsh::CMD', $lines_ref,
        _batsh => __PACKAGE__,
        _pushd_stack => [],
    );
}

###############################################################################
# _exec_sh_section -- run SH lines through BATsh::SH
###############################################################################
sub _exec_sh_section {
    my (@lines) = @_;
    my @batch = ();
    for my $line (@lines) {
        (my $s = $line) =~ s/\r?\n\z//;
        $s =~ s/\A\s+//;
        if ($s =~ /\A(?:source|\.)\s+(\S+\.batsh)/) {
            my $bfile = $1;
            _flush_sh(\@batch) if @batch; @batch = ();
            eval { source_file('', $bfile) };
            warn $@ if $@;
            next;
        }
        push @batch, $line;
    }
    _flush_sh(\@batch) if @batch;
}

sub _flush_sh {
    my ($lines_ref) = @_;
    return unless @{$lines_ref};
    BATsh::SH::exec_block('BATsh::SH', $lines_ref,
        _batsh => __PACKAGE__,
    );
}

###############################################################################
# _process_lines -- main dispatcher
###############################################################################
sub _process_lines {
    my (@source) = @_;
    @source = _extract_subroutines(@source);

    my @pending = (); my $cur_mode = ''; my $depth = 0;

    # Here-document tracking: while a here-document body is being collected,
    # body lines are appended to the current section verbatim and are NOT
    # reclassified (so an uppercase-leading body line is not misrouted to CMD).
    # Activation is deferred by one line so the trigger line itself is
    # classified normally.
    my $hd_delim         = undef;   # active delimiter (collecting body)
    my $hd_dash          = 0;
    my $pending_hd_delim = undef;   # set on the trigger line, activated next iter
    my $pending_hd_dash  = 0;

    for my $raw (@source) {
        chomp $raw;

        # Promote a pending here-document to active (trigger line already pushed)
        if (defined $pending_hd_delim) {
            $hd_delim         = $pending_hd_delim;
            $hd_dash          = $pending_hd_dash;
            $pending_hd_delim = undef;
        }

        # Collecting a here-document body: pass through unclassified.
        if (defined $hd_delim) {
            push @pending, $raw;
            my $probe = $raw;
            $probe =~ s/\A\t+// if $hd_dash;
            $hd_delim = undef if $probe eq $hd_delim;
            next;
        }

        my ($mode, $line, $first) = _parse_line($raw);

        # Detect a here-document opener on an SH line; defer activation so the
        # trigger line is classified normally this iteration.
        if ($mode eq 'SH') {
            my @hd = BATsh::SH::_hd_detect($raw);
            if (@hd) {
                $pending_hd_delim = $hd[2];
                $pending_hd_dash  = $hd[1];
            }
        }

        if ($mode eq 'EMPTY' || $mode eq 'COMMENT') {
            # A comment carries no execution effect, so it must never be handed
            # to an interpreter verbatim.  A CMD-style comment (":: ..." or
            # "REM ...") carried into an SH section would be dispatched to the
            # external shell (SH treats only "#" as a comment), and any "( )" or
            # other shell metacharacter in the comment then makes /bin/sh fail
            # with a syntax error.  The reverse ("# ..." into CMD) is likewise
            # not a CMD comment.  Routing it as a BLANK line is skipped
            # identically by both interpreters and in every nesting depth, and
            # avoids the real cmd.exe quirk of "::" inside a "( )" block.
            push @pending, '' if $cur_mode ne '';
            next;
        }

        if ($cur_mode eq '') {
            $cur_mode = $mode; $depth = 0;
            push @pending, $line;
            $depth += ($mode eq 'CMD') ? _cmd_paren_delta($line) : _sh_depth_delta($line);
        }
        elsif ($mode eq $cur_mode) {
            push @pending, $line;
            $depth += ($mode eq 'CMD') ? _cmd_paren_delta($line) : _sh_depth_delta($line);
            $depth = 0 if $depth < 0;
        }
        else {
            if ($depth > 0) {
                push @pending, $line;
                $depth += ($cur_mode eq 'CMD') ? _cmd_paren_delta($line) : _sh_depth_delta($line);
                $depth = 0 if $depth < 0;
            }
            else {
                _flush_section($cur_mode, @pending) if @pending;
                @pending = ($line); $cur_mode = $mode; $depth = 0;
                $depth += ($mode eq 'CMD') ? _cmd_paren_delta($line) : _sh_depth_delta($line);
            }
        }
    }
    _flush_section($cur_mode, @pending) if @pending;
}

sub _flush_section {
    my ($mode, @lines) = @_;
    return unless @lines;
    if ($mode eq 'CMD') { _exec_cmd_section(@lines) }
    else                { _exec_sh_section(@lines) }
}

###############################################################################
# REPL
###############################################################################
sub repl {
    my ($class_or_self) = @_;
    _ensure_env_init();
    print "BATsh $VERSION - Bilingual Shell\n";
    print "Uppercase => CMD mode, lowercase => SH mode. EXIT/exit to quit.\n\n";

    my (@buf, $depth, $cur_mode) = ((), 0, '');
    my ($hd_delim, $hd_dash, $pending_hd_delim, $pending_hd_dash)
        = (undef, 0, undef, 0);
    while (1) {
        print $depth > 0 || defined($hd_delim) ? '    +> ' : 'BATsh> ';
        my $line = ;
        last unless defined $line;
        chomp $line;

        # Promote pending here-document (trigger already buffered)
        if (defined $pending_hd_delim) {
            $hd_delim = $pending_hd_delim; $hd_dash = $pending_hd_dash;
            $pending_hd_delim = undef;
        }
        # Collecting here-document body: buffer verbatim, do not flush/classify
        if (defined $hd_delim) {
            push @buf, $line;
            my $probe = $line;
            $probe =~ s/\A\t+// if $hd_dash;
            $hd_delim = undef if $probe eq $hd_delim;
            if (!defined($hd_delim) && $depth == 0) {
                _flush_section($cur_mode, @buf);
                @buf = (); $cur_mode = ''; $depth = 0;
            }
            next;
        }

        if ($line =~ /\A\s*(?:EXIT|exit)\s*\z/) { print "Bye.\n"; last }
        next if $depth == 0 && $line =~ /\A\s*\z/;
        push @buf, $line;
        my (undef, undef, $first) = _parse_line($line);
        $cur_mode = classify_token($first) if $depth == 0 && $cur_mode eq '';
        # Detect here-document opener (SH only); defer activation one line
        if ($cur_mode eq 'SH') {
            my @hd = BATsh::SH::_hd_detect($line);
            if (@hd) { $pending_hd_delim = $hd[2]; $pending_hd_dash = $hd[1] }
        }
        $depth += ($cur_mode eq 'CMD') ? _cmd_paren_delta($line) : _sh_depth_delta($line);
        $depth = 0 if $depth < 0;
        if ($depth == 0 && !defined($pending_hd_delim)) {
            _flush_section($cur_mode, @buf);
            @buf = (); $cur_mode = ''; $depth = 0;
        }
    }
}

###############################################################################
# Accessors
###############################################################################
sub version      { return $VERSION }
sub sh_available { return 1 }   # always: built-in SH interpreter

###############################################################################
# Run as script
###############################################################################
unless (caller) {
    BATsh::Env::init();
    if (@ARGV == 0) { BATsh->repl() }
    elsif ($ARGV[0] eq '-e') { shift @ARGV; BATsh->run_string(join("\n", @ARGV)) }
    else { BATsh->run($ARGV[0]) }
}

1;

__END__