123 lines
2.2 KiB
Go
123 lines
2.2 KiB
Go
package command
|
|
|
|
import (
|
|
"errors"
|
|
"strings"
|
|
)
|
|
|
|
const (
|
|
RootNode = iota
|
|
LiteralNode
|
|
ArgumentNode
|
|
)
|
|
|
|
type Graph struct {
|
|
nodes []Node
|
|
}
|
|
|
|
func NewGraph() *Graph {
|
|
g := new(Graph)
|
|
root := Node{
|
|
g: g,
|
|
kind: RootNode,
|
|
}
|
|
g.nodes = append(g.nodes, root)
|
|
return g
|
|
}
|
|
|
|
func (g *Graph) Run(cmd string) error {
|
|
var args []ParsedData
|
|
node := &g.nodes[0] // root
|
|
for {
|
|
left, value, next, err := node.parse(cmd)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
args = append(args, value)
|
|
left = strings.TrimSpace(left)
|
|
if len(left) == 0 {
|
|
err := node.Run(args)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
if next == 0 {
|
|
return errors.New("command contains extra text: " + left)
|
|
}
|
|
|
|
cmd = left
|
|
node = &g.nodes[next]
|
|
}
|
|
}
|
|
|
|
type ParsedData interface{}
|
|
|
|
type HandlerFunc func(args []ParsedData) error
|
|
|
|
type Node struct {
|
|
g *Graph
|
|
index int32
|
|
kind byte
|
|
Name string
|
|
Children []int32
|
|
SuggestionsType string
|
|
Parser Parser
|
|
Run HandlerFunc
|
|
}
|
|
type Literal Node
|
|
type Argument Node
|
|
|
|
func (n *Node) parse(cmd string) (left string, value ParsedData, next int32, err error) {
|
|
switch n.kind & 0x03 {
|
|
case RootNode:
|
|
left = cmd
|
|
value = nil
|
|
err = nil
|
|
case LiteralNode:
|
|
if !strings.HasPrefix(cmd, n.Name) {
|
|
panic("expect " + cmd + " prefixed with " + n.Name)
|
|
}
|
|
left = strings.TrimPrefix(cmd, n.Name)
|
|
value = LiteralData(n.Name)
|
|
case ArgumentNode:
|
|
left, value, err = n.Parser.Parse(cmd)
|
|
if err != nil {
|
|
return "", nil, 0, err
|
|
}
|
|
default:
|
|
panic("unreachable")
|
|
}
|
|
// find next
|
|
if len(n.Children) > 0 {
|
|
// look up the first child's type
|
|
switch n.g.nodes[n.Children[0]].kind & 0x03 {
|
|
case RootNode:
|
|
panic("root node can't be child")
|
|
default:
|
|
panic("unreachable")
|
|
case LiteralNode:
|
|
_, value, err := StringParser(0).Parse(strings.TrimSpace(left))
|
|
if err != nil {
|
|
return "", nil, 0, err
|
|
}
|
|
literal := value.(string)
|
|
for _, i := range n.Children {
|
|
if n.g.nodes[i].Name == literal {
|
|
next = i
|
|
break
|
|
}
|
|
}
|
|
case ArgumentNode:
|
|
next = n.Children[0]
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func unhandledCmd([]ParsedData) error {
|
|
return errors.New("unhandled function")
|
|
}
|
|
|
|
type LiteralData string
|