forked from x/icebergs
374 lines
9.0 KiB
Go
374 lines
9.0 KiB
Go
package yac
|
|
|
|
import (
|
|
"encoding/json"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
ice "shylinux.com/x/icebergs"
|
|
"shylinux.com/x/icebergs/base/web"
|
|
kit "shylinux.com/x/toolkits"
|
|
)
|
|
|
|
type Any = ice.Any
|
|
type Dict struct{ value map[string]Any }
|
|
type List struct{ value []Any }
|
|
type Value struct{ list []Any }
|
|
type String struct{ value string }
|
|
type Number struct{ value string }
|
|
type Boolean struct{ value bool }
|
|
type Caller interface{ Call(string, ...Any) Any }
|
|
type Operater interface{ Operate(string, Any) Any }
|
|
|
|
func (s Dict) MarshalJSON() ([]byte, error) { return json.Marshal(s.value) }
|
|
func (s List) MarshalJSON() ([]byte, error) { return json.Marshal(s.value) }
|
|
func (s String) MarshalJSON() ([]byte, error) { return json.Marshal(s.value) }
|
|
func (s Number) MarshalJSON() ([]byte, error) { return json.Marshal(s.value) }
|
|
func (s Boolean) MarshalJSON() ([]byte, error) { return json.Marshal(s.value) }
|
|
|
|
func (s String) String() string { return s.value }
|
|
func wrap(v Any) Any {
|
|
switch v := v.(type) {
|
|
case map[string]Any:
|
|
return Dict{v}
|
|
case []Any:
|
|
return List{v}
|
|
case string:
|
|
return String{v}
|
|
case int:
|
|
return Number{kit.Format(v)}
|
|
case bool:
|
|
return Boolean{v}
|
|
default:
|
|
return v
|
|
}
|
|
}
|
|
func Trans(v Any) Any {
|
|
switch v := v.(type) {
|
|
case Dict:
|
|
return v.value
|
|
case List:
|
|
return v.value
|
|
case Value:
|
|
if len(v.list) > 0 {
|
|
return Trans(v.list[0])
|
|
} else {
|
|
return nil
|
|
}
|
|
case String:
|
|
return v.value
|
|
case Number:
|
|
return v.value
|
|
case Boolean:
|
|
return v.value
|
|
default:
|
|
return v
|
|
}
|
|
}
|
|
func (s Dict) Operate(op string, v Any) Any {
|
|
switch op {
|
|
case RANGE:
|
|
switch list := v.(type) {
|
|
case []Any:
|
|
if key := kit.SortedKey(s.value); list != nil && len(list) > 2 {
|
|
if i := kit.Int(list[2]) + 1; i < len(key) {
|
|
return []Any{key[i], s.value[key[i]], i}
|
|
}
|
|
} else {
|
|
if len(key) > 0 {
|
|
return []Any{key[0], s.value[key[0]], 0}
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
case SUBS:
|
|
return wrap(kit.Value(s.value, kit.Format(v)))
|
|
default:
|
|
s.value[op] = v
|
|
return v
|
|
}
|
|
return nil
|
|
}
|
|
func (s List) Operate(op string, v Any) Any {
|
|
switch op {
|
|
case RANGE:
|
|
switch list := v.(type) {
|
|
case []Any:
|
|
if list != nil && len(list) > 1 {
|
|
if i := kit.Int(list[0]) + 1; i < len(s.value) {
|
|
return []Any{i, s.value[i]}
|
|
}
|
|
} else {
|
|
if len(s.value) > 0 {
|
|
return []Any{0, s.value[0]}
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
case SUBS:
|
|
return wrap(kit.Value(s.value, kit.Format(v)))
|
|
default:
|
|
if i, e := strconv.ParseInt(op, 10, 32); e == nil {
|
|
switch (int(i)+2+len(s.value)+2)%(len(s.value)+2) - 2 {
|
|
case -1:
|
|
s.value = append([]Any{v}, s.value...)
|
|
case -2:
|
|
s.value = append(s.value, v)
|
|
default:
|
|
s.value[i] = v
|
|
}
|
|
return v
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
func (s String) Operate(op string, v Any) Any {
|
|
switch a, b := s.value, kit.Format(v); op {
|
|
case "+":
|
|
return String{a + b}
|
|
case "-":
|
|
return String{strings.Replace(a, b, "", -1)}
|
|
case "<":
|
|
return Boolean{a < b}
|
|
case ">":
|
|
return Boolean{a > b}
|
|
case ">=":
|
|
return Boolean{a >= b}
|
|
case "<=":
|
|
return Boolean{a <= b}
|
|
case "!=":
|
|
return Boolean{a != b}
|
|
case "==":
|
|
return Boolean{a == b}
|
|
default:
|
|
return nil
|
|
}
|
|
}
|
|
func (s Number) Operate(op string, v Any) Any {
|
|
switch a, b := kit.Int(s.value), kit.Int(v); op {
|
|
case "++":
|
|
return Number{kit.Format(a + 1)}
|
|
case "--":
|
|
return Number{kit.Format(a - 1)}
|
|
case "*":
|
|
return Number{kit.Format(a * b)}
|
|
case "/":
|
|
return Number{kit.Format(a / b)}
|
|
case "+":
|
|
return Number{kit.Format(a + b)}
|
|
case "-":
|
|
return Number{kit.Format(a - b)}
|
|
case "<":
|
|
return Boolean{a < b}
|
|
case ">":
|
|
return Boolean{a > b}
|
|
case ">=":
|
|
return Boolean{a >= b}
|
|
case "<=":
|
|
return Boolean{a <= b}
|
|
case "!=":
|
|
return Boolean{a != b}
|
|
case "==":
|
|
return Boolean{a == b}
|
|
default:
|
|
return nil
|
|
}
|
|
}
|
|
func (s Boolean) Operate(op string, v Any) Any {
|
|
switch a, b := s.value, !kit.IsIn(kit.Format(v), "", "0", ice.FALSE); op {
|
|
case "&&":
|
|
return Boolean{a && b}
|
|
case "||":
|
|
return Boolean{a || b}
|
|
case "!":
|
|
return Boolean{!a}
|
|
default:
|
|
return nil
|
|
}
|
|
}
|
|
func (s *Stack) load(m *ice.Message, cb func(*Frame)) *Stack {
|
|
f := s.peekf()
|
|
f.value["kit"] = func(m *ice.Message, key string, arg ...Any) Any {
|
|
switch key {
|
|
case "Dict":
|
|
return kit.Dict(arg...)
|
|
case "List":
|
|
return kit.List(arg...)
|
|
case "Format":
|
|
return kit.Format(arg[0], arg[1:]...)
|
|
case "Formats":
|
|
return kit.Formats(arg[0])
|
|
default:
|
|
m.ErrorNotImplement(key)
|
|
return nil
|
|
}
|
|
}
|
|
f.value["ice.Cmd"] = func(m *ice.Message, key string, arg ...Any) Any {
|
|
stack := m.Optionv(ice.YAC_STACK).(*Stack)
|
|
command := &ice.Command{Name: "list hash auto", Help: "示例", Actions: ice.Actions{}}
|
|
obj := arg[1].(Object)
|
|
for k, v := range obj.index.index {
|
|
switch v.(type) {
|
|
case Function:
|
|
if k == "List" {
|
|
command.Hand = stack.Handler(v)
|
|
} else {
|
|
command.Actions[k] = &ice.Action{Hand: stack.Handler(v)}
|
|
}
|
|
case Field:
|
|
}
|
|
}
|
|
command.List = ice.SplitCmd(command.Name, command.Actions)
|
|
last, list := ice.Index, kit.Split(kit.Format(arg[0]), ice.PT)
|
|
for i := 1; i < len(list); i++ {
|
|
has := false
|
|
if ice.Pulse.Search(strings.Join(list[:i], ice.PT)+ice.PT, func(p *ice.Context, s *ice.Context) { has, last = true, s }); !has {
|
|
context := &ice.Context{Name: list[i-1], Caches: ice.Caches{ice.CTX_FOLLOW: &ice.Cache{Value: strings.Join(list[:i], ice.PT)}}}
|
|
last = last.Register(context, &web.Frame{})
|
|
}
|
|
kit.If(i == len(list)-1, func() {
|
|
last.Merge(&ice.Context{Commands: ice.Commands{list[i]: command}})
|
|
last.Merge(last)
|
|
})
|
|
}
|
|
m.Debug("what %#v", command)
|
|
return nil
|
|
}
|
|
f.value["ice.MergeActions"] = func(m *ice.Message, key string, arg ...Any) Any {
|
|
_actions := ice.Actions{}
|
|
for _, v := range arg {
|
|
ice.MergeActions(_actions, TransActions(m, v))
|
|
}
|
|
res := Dict{value: kit.Dict()}
|
|
for k, v := range _actions {
|
|
res.value[k] = Object{value: Dict{kit.Dict("Name", v.Name, "Help", v.Help, "Hand", v.Hand)}}
|
|
}
|
|
return res
|
|
}
|
|
for k, v := range ice.Info.Stack {
|
|
if strings.HasPrefix(k, "web.code.") {
|
|
k = strings.TrimPrefix(k, "web.")
|
|
}
|
|
f.value[k] = v
|
|
}
|
|
f.value["m"] = Message{m}
|
|
kit.If(cb != nil, func() { cb(f) })
|
|
return s
|
|
}
|
|
|
|
func (m Message) Call(cmd string, arg ...Any) Any {
|
|
str := func(v Any) string { return kit.Format(Trans(v)) }
|
|
switch cmd {
|
|
case "Option":
|
|
return m.Option(str(arg[0]), arg[1:]...)
|
|
case "Cmd":
|
|
return Message{m.Cmd(arg...)}
|
|
case "Cmdy":
|
|
m.Cmdy(arg...)
|
|
case "Copy":
|
|
m.Copy(arg[0].(Message).Message, kit.Simple(arg[1:]...)...)
|
|
case "Push":
|
|
m.Push(str(arg[0]), arg[1], arg[2:]...)
|
|
case "Echo":
|
|
m.Echo(str(arg[0]), arg[1:]...)
|
|
case "Action":
|
|
m.Action(arg...)
|
|
case "Display":
|
|
if len(arg) > 0 {
|
|
m.ProcessDisplay(arg...)
|
|
} else {
|
|
m.ProcessDisplay(kit.Format("%s?_t=%d", Trans(_parse_stack(m.Message).value(m.Message, "_script")), time.Now().Unix()))
|
|
}
|
|
case "StatusTime":
|
|
m.StatusTime(arg...)
|
|
case "DebugStack":
|
|
s := _parse_stack(m.Message)
|
|
list := []string{}
|
|
s.stack(func(f *Frame, i int) bool {
|
|
list = append(list, kit.Format("stack: %s", f.key))
|
|
kit.For(f.value, func(k string, v Any) {
|
|
list = append(list, kit.Format("stack: %s %s:%#v", f.key, k, v))
|
|
})
|
|
return false
|
|
})
|
|
m.Debug(ice.NL + strings.Join(list, ice.NL))
|
|
case "Sleep":
|
|
m.Sleep(str(arg[0]))
|
|
case "Table":
|
|
s := _parse_stack(m.Message)
|
|
m.Table(func(val ice.Maps) { s.calls(m.Message, arg[0], nil, nil, Dict{kit.Dict(val)}) })
|
|
default:
|
|
m.ErrorNotImplement(cmd)
|
|
}
|
|
return m
|
|
}
|
|
|
|
type Message struct{ *ice.Message }
|
|
|
|
func TransContext(m *ice.Message, key string, arg ...Any) *ice.Context {
|
|
s := &ice.Context{Caches: ice.Caches{ice.CTX_FOLLOW: &ice.Cache{}}}
|
|
kit.For(arg[0], func(k string, v ice.Any) {
|
|
switch k {
|
|
case "Name":
|
|
s.Name = kit.Format(Trans(v))
|
|
case "Help":
|
|
s.Help = kit.Format(Trans(v))
|
|
case "Commands":
|
|
s.Commands = TransCommands(m, v)
|
|
}
|
|
})
|
|
s.Merge(s).Cap(ice.CTX_FOLLOW, kit.Keys(key, s.Name))
|
|
return s
|
|
}
|
|
func TransCommands(m *ice.Message, arg ...Any) ice.Commands {
|
|
commands := ice.Commands{}
|
|
stack := m.Optionv(ice.YAC_STACK).(*Stack)
|
|
kit.For(arg[0], func(k string, v ice.Any) {
|
|
s := &ice.Command{}
|
|
kit.For(v, func(k string, v ice.Any) {
|
|
switch k {
|
|
case "Name":
|
|
s.Name = kit.Format(Trans(v))
|
|
case "Help":
|
|
s.Help = kit.Format(Trans(v))
|
|
case "Actions":
|
|
s.Actions = TransActions(m, v)
|
|
case "Hand":
|
|
s.Hand = func(m *ice.Message, arg ...string) {
|
|
msg := m.Spawn(Index).Spawn(m.Target())
|
|
stack.Action(msg, v, nil, arg...)
|
|
m.Copy(msg)
|
|
}
|
|
}
|
|
})
|
|
commands[k] = s
|
|
})
|
|
return commands
|
|
}
|
|
func TransActions(m *ice.Message, arg ...Any) ice.Actions {
|
|
switch v := arg[0].(type) {
|
|
case ice.Actions:
|
|
return v
|
|
}
|
|
actions := ice.Actions{}
|
|
stack := m.Optionv(ice.YAC_STACK).(*Stack)
|
|
kit.For(arg[0], func(k string, v ice.Any) {
|
|
s := &ice.Action{}
|
|
switch k {
|
|
case "Name":
|
|
s.Name = kit.Format(Trans(v))
|
|
case "Help":
|
|
s.Help = kit.Format(Trans(v))
|
|
case "Hand":
|
|
s.Hand = func(m *ice.Message, arg ...string) {
|
|
msg := m.Spawn(Index).Spawn(m.Target())
|
|
stack.Action(msg, v, nil, arg...)
|
|
m.Copy(msg)
|
|
}
|
|
}
|
|
actions[k] = s
|
|
})
|
|
return actions
|
|
}
|