bashkit 0.5.0

Awesomely fast virtual sandbox with bash and file system
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

//! Token types for the lexer
//!
//! Many token types are defined for future implementation phases.

#![allow(dead_code)]

/// Token types produced by the lexer.
#[derive(Debug, Clone, PartialEq)]
pub enum Token {
    /// A word (command name, argument, etc.) - may contain variable expansions
    Word(String),

    /// A literal word (single-quoted) - no variable expansion
    LiteralWord(String),

    /// A double-quoted word - may contain variable expansions inside,
    /// but is marked as quoted (affects heredoc delimiter semantics)
    QuotedWord(String),

    /// A word that mixes quoted and unquoted segments where the unquoted
    /// portion contains glob metacharacters (*, ?, [).  Semantically
    /// equivalent to QuotedWord for IFS splitting (suppressed), but the
    /// interpreter must still perform glob expansion on the result.
    /// Example: `"$var"*.ext` or `./"$dir"/*.log`
    QuotedGlobWord(String),

    /// Newline character
    Newline,

    /// Semicolon (;)
    Semicolon,

    /// Double semicolon (;;) — case break
    DoubleSemicolon,

    /// Case fallthrough (;&)
    SemiAmp,

    /// Case continue-matching (;;&)
    DoubleSemiAmp,

    /// Pipe (|)
    Pipe,

    /// And (&&)
    And,

    /// Or (||)
    Or,

    /// Background (&)
    Background,

    /// Redirect output (>)
    RedirectOut,

    /// Redirect output append (>>)
    RedirectAppend,

    /// Redirect input (<)
    RedirectIn,

    /// Here document (<<)
    HereDoc,

    /// Here document with tab stripping (<<-)
    HereDocStrip,

    /// Here string (<<<)
    HereString,

    /// Left parenthesis (()
    LeftParen,

    /// Right parenthesis ())
    RightParen,

    /// Double left parenthesis ((()
    DoubleLeftParen,

    /// Double right parenthesis ()))
    DoubleRightParen,

    /// Left brace ({)
    LeftBrace,

    /// Right brace (})
    RightBrace,

    /// Double left bracket ([[)
    DoubleLeftBracket,

    /// Double right bracket (]])
    DoubleRightBracket,

    /// Assignment (=)
    Assignment,

    /// Process substitution input <(cmd)
    ProcessSubIn,

    /// Process substitution output >(cmd)
    ProcessSubOut,

    /// Redirect both stdout and stderr (&>)
    RedirectBoth,

    /// Clobber redirect (>|) - force overwrite even with noclobber
    Clobber,

    /// Duplicate output file descriptor (>&)
    DupOutput,

    /// Duplicate input file descriptor (<&)
    DupInput,

    /// Redirect with file descriptor (e.g., 2>)
    RedirectFd(i32),

    /// Redirect and append with file descriptor (e.g., 2>>)
    RedirectFdAppend(i32),

    /// Duplicate fd to another (e.g., 2>&1)
    DupFd(i32, i32),

    /// Duplicate input fd to another (e.g., 4<&0)
    DupFdIn(i32, i32),

    /// Close fd (e.g., 4<&- or 4>&-)
    DupFdClose(i32),

    /// Redirect input with file descriptor (e.g., 4<)
    RedirectFdIn(i32),

    /// Lexer error (e.g., unterminated string)
    Error(String),
}