Go+goyaccでシェルを実装する

$ go get github.com/lufia/qsh

$ qsh

# この行は無視する
echo a#b    # "a#b"と出力
echo '#E'   # "#E"と出力

ls -l
gitlab/users -a  # $HOME/bin/gitlab/usersを実行

ranks=(S A B C)
echo $ranks     # "S A B C"と出力

API_TOKEN=xxxx  # 全て大文字なら環境変数になる
bash -c 'echo $API_TOKEN'   # "xxx"と出力

PATH=(/bin /usr/bin)
echo $PATH           # "/bin /usr/bin"と出力
bash -c 'echo $PATH' # "/bin:/usr/bin"と出力

Jan=1
January=Jan
c=January
echo $$$c   # "1"と出力

touch 'a b'
args=(-l 'a b')
ls $args
# ls -l 'a b'を実行

for i in 1 2 3 {
    echo $i
}

if { echo a | grep -q . } {
    echo match
}

cmp -s a b && echo same  # aとbが同じ内容ならsameと出力
cmp -s a b || echo diff  # aとbが異なる内容ならdiffと出力

echo hello >out   # 出力
echo hello >>out  # 追記
cat <in           # 入力
echo hello | wc   # パイプ

package main

var SampleModule = map[string]string{
    // Hello関数をhelloという名前でシェルから呼び出せるようにする
    "hello": "Hello",
}

func Hello(args []string) ([]string, error) {
    a := make([]string, 0, len(args)+1)
    a = append(a, "hello")
    return append(a, args...), nil
}

$ go build -buildmode=plugin sample.go

load sample          # プラグインの読み込み
echo ${hello world}  # "hello world"と出力

if { true } {
    echo a is $a | wc
}

type Node struct {
    Type int
    Str  string
}

Node{Type: IF}
Node{Type: '{'}
Node{Type: WORD, Str: "true"}
Node{Type: '}'}
Node{Type: '{'}
Node{Type: '\n'}
Node{Type: WORD, Str: "echo"}
Node{Type: WORD, Str: "a"}
Node{Type: WORD, Str: "is"}
Node{Type: '$'}
Node{Type: WORD, Str: "a"}
Node{Type: '|'}
Node{Type: WORD, Str: "wc"}
Node{Type: '\n'}
Node{Type: '}'}

type yyLexer interface {
    Lex(lval *yySymType) int
    Error(e string)
}

const EOF = -1

type Lexer struct {
    f   io.RuneScanner
    buf bytes.Buffer
}

func (l *Lexer) Lex(lval *yySymType) int {
    l.buf.Reset()
    var c rune
    for {
        c, _, err := l.f.ReadRune()
        if err != nil {
            return EOF
        }
        if c != ' ' && c != '\t' {
            break
        }
    }
    switch c {
    case EOF:
        return -1
    case '$', '{', '}', '\n', '|':
        return int(c)
    case '\'':
        // 省略
    default:
        l.buf.WriteRune(c)
        for {
            c, _, err := l.f.ReadRune()
            if err != nil {
                break
            }
            if c == EOF || unicode.IsSpace(c) || c == '$' || c == '{' || ... {
                l.f.UnreadRune()
                break
            }
            l.buf.WriteRune(c)
        }
        lval.tree = &Node{Type: WORD, Str: l.buf.String()}
        return WORD
    }
}

%term IF
%term WORD
%left IF
%left '|'
%%
prog:
    {
        return 1
    }
|   line '\n'
    {
        Compile($1)
        return 0
    }

line:
    cmd
|   cmd ';' line    { $$ = New(LIST, $1, $3) }

cmd:
|   IF block block  { $$ = New(IF, $2, $3) }
|   simple
|   cmd '|' cmd     { $$ = New(PIPE, $1, $3) }

block:
    '{' body '}'    { $$ = New(BLOCK, $2, nil) }

body:
    cmd
|   cmd ';' cmd     { $$ = New(LIST, $1, $3) }
|   cmd '\n' cmd    { $$ = New(LIST, $1, $3) }

simple:
    word
|   simple word     { $$ = New(LIST, $1, $2) }

word:
    '$' word        { $$ = New(VAR, $2, nil) }
|   WORD

%union {
    tree *Node
}
%type<tree> line block body assign
%type<tree> cmd simple word
%type<tree> WORD

word:
    '$' word    { $$ = New(VAR, $2, nil) }
|   WORD        { $$ = $1 }

var l Lexer
f := bufio.NewReader(os.Stdin)
l.Init(f)
for yyParse(&l) == 0 {
}

prog:
    {
        return 1
    }
|   line '\n'
    {
        return 0
    }

if { true } {
    echo a is $a | wc
}

type Node struct {
    Type  int
    Str   string
    Left  *Node
    Right *Node
}

# ls $opt
MARK       # 新規スタックを作成する
PUSH ls    # lsという文字をスタックにpush
PUSH opt   # optという文字をスタックにpush
VAR        # 1つ取り出して変数参照; 結果をスタックに入れる
SIMPLE     # スタックに溜まっているリストを実行

# if { cmp -s a b } {
#     echo ok
# }
MARK       # 新規スタックを作成する
PUSH cmp   # cmpという文字をスタックにpush
PUSH -s    # -sという文字をスタックにpush
PUSH a     # aという文字をスタックにpush
PUSH b     # bという文字をスタックにpush
SIMPLE     # スタックに溜まっているリストを実行
IF         # 実行結果が正常終了なら1つ飛ばす(GOTOをスキップ)
GOTO end   # endラベルへジャンプ
MARK       # 新規スタックを作成する
PUSH echo  # echoという文字をスタックにpush
PUSH ok    # okという文字をスタックにpush
SIMPLE     # スタックに溜まっているリストを実行
end:       # endラベル; ls aがエラーならここに飛ぶ

type Cmd struct {
    pc int
}

type Code struct {
    steps []func(cmd *Cmd)
}

func (c *Code) emit(f func(cmd *Cmd)) {
    c.steps = append(c.steps, f)
}

func build(c *Code, p *Node) {
    if p == nil {
        return
    }
    switch p.Type {
    case WORD:
        c.emit(Push(p.Str))
    case SIMPLE:
        c.emit(Mark)
        build(c, p.Left)
        c.emit(Simple)
    case LIST:
        build(c, p.Left)
        build(c, p.Right)
    case BLOCK:
        build(c, p.Left)
    case VAR:
        c.emit(Mark)
        build(c, p.Left)
        c.emit(Var)
    case IF:
        build(c, p.Left)
        c.emit(If)
        var end Label
        c.emit(Goto(&end))
        build(c, p.Right)
        end.pos = len(c.steps)
    }
}