add shy.array

src/contexts/cli/cli.go

@@ -300,9 +300,6 @@ var Index = &ctx.Context{Name: "cli", Help: "管理中心",
 			if len(cmd.Env) > 0 {
 				m.Log("info", "env %v", cmd.Env)
 			}
-			for _, k := range []string{"PATH", "HOME"} {
-				cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", k, os.Getenv(k)))
-			}
 
 			// 交互命令
 			if m.Options("cmd_active") || kit.Right(conf["active"]) {

src/contexts/cli/version.go

@@ -4,5 +4,5 @@ var version = struct {
 	host string
 	self int
 }{
-	"2019-08-01 17:49:56", "ZYB-20190522USI", 350,
+	"2019-08-02 22:20:17", "ZYB-20190522USI", 367,
 }

src/contexts/ctx/ctx.go

@@ -815,7 +815,8 @@ var Index = &Context{Name: "ctx", Help: "模块中心", Server: &CTX{},
 			}
 
 			msg := m.Optionv("bio.msg").(*Message)
-			if len(arg) == 0 {
+			switch len(arg) {
+			case 0:
 				vals := map[string]interface{}{}
 				list := []string{}
 
@@ -841,13 +842,15 @@ var Index = &Context{Name: "ctx", Help: "模块中心", Server: &CTX{},
 					m.Push("val", kit.Format(vals[k]))
 				}
 				m.Table()
-				return
+			case 1:
-			}
+				switch v := msg.Optionv(arg[0]).(type) {
-			switch v := msg.Optionv(arg[0]).(type) {
+				case []string:
-			case []string:
+					m.Echo(strings.Join(v, ""))
-				m.Echo(strings.Join(v, ""))
+				default:
+					m.Echo(kit.Format(v))
+				}
 			default:
-				m.Echo(kit.Format(v))
+				m.Echo(m.Option(arg[0], arg[1]))
 			}
 			return
 		}},

src/contexts/web/web.go

@@ -563,8 +563,8 @@ var Index = &ctx.Context{Name: "web", Help: "应用中心",
 										data = kit.Chain(data, k, v[0])
 									}
 								} else {
-									for _, val := range v {
+									for i, val := range v {
-										if i, e := strconv.Atoi(v[0]); e == nil {
+										if i, e := strconv.Atoi(v[i]); e == nil {
 											data = kit.Chain(data, []string{k, "-2"}, i)
 										} else {
 											data = kit.Chain(data, []string{k, "-2"}, val)

src/contexts/yac/yac.go

@@ -2,7 +2,8 @@ package yac
 
 import (
 	"contexts/ctx"
-	"toolkit"
+	"sort"
+	kit "toolkit"
 
 	"fmt"
 	"os"
@@ -334,7 +335,12 @@ var Index = &ctx.Context{Name: "yac", Help: "语法中心",
 			map[string]interface{}{"page": "exe", "hash": "exe", "word": []interface{}{"$", "(", "cmd", ")"}},
 			map[string]interface{}{"page": "stm", "hash": "var", "word": []interface{}{"var", "key", "opt{", "=", "exp", "}"}},
 			map[string]interface{}{"page": "stm", "hash": "let", "word": []interface{}{"let", "key", "opt{", "=", "exp", "}"}},
+			map[string]interface{}{"page": "stm", "hash": "let", "word": []interface{}{"let", "key", "=", "\\[", "rep{", "exp", "}", "\\]"}},
+			map[string]interface{}{"page": "stm", "hash": "let", "word": []interface{}{"let", "key", "=", "\\{", "rep{", "exp", "}", "\\}"}},
 			map[string]interface{}{"page": "stm", "hash": "if", "word": []interface{}{"if", "exp"}},
+			map[string]interface{}{"page": "stm", "hash": "for", "word": []interface{}{"for", "key", "key", "key", "in", "key"}},
+			map[string]interface{}{"page": "stm", "hash": "for", "word": []interface{}{"for", "key", "key", "in", "key"}},
+			map[string]interface{}{"page": "stm", "hash": "for", "word": []interface{}{"for", "key", "in", "key"}},
 			map[string]interface{}{"page": "stm", "hash": "for", "word": []interface{}{"for", "rep{", "exp", "}"}},
 			map[string]interface{}{"page": "stm", "hash": "fun", "word": []interface{}{"fun", "key", "rep{", "exp", "}"}},
 			map[string]interface{}{"page": "stm", "hash": "kit", "word": []interface{}{"kit", "rep{", "exp", "}"}},
@@ -993,8 +999,27 @@ var Index = &ctx.Context{Name: "yac", Help: "语法中心",
 		}},
 		"let": &ctx.Command{Name: "let a = exp", Help: "设置变量, a: 变量名, exp: 表达式", Hand: func(m *ctx.Message, c *ctx.Context, key string, arg ...string) (e error) {
 			if stack, ok := m.Optionv("bio.stack").(*kit.Stack); ok {
-				m.Log("stack", "%v = %v", arg[1], arg[3])
+				switch arg[3] {
-				stack.Hash(arg[1], arg[3])
+				case "[":
+					list := []interface{}{}
+					for i := 4; i < len(arg)-1; i++ {
+						list = append(list, arg[i])
+					}
+					m.Log("stack", "%v = %v", arg[1], list)
+					stack.Hash(arg[1], list)
+
+				case "{":
+					list := map[string]interface{}{}
+					for i := 4; i < len(arg)-2; i += 2 {
+						list[arg[i]] = arg[i+1]
+					}
+					m.Log("stack", "%v = %v", arg[1], list)
+					stack.Hash(arg[1], list)
+
+				default:
+					m.Log("stack", "%v = %v", arg[1], arg[3])
+					stack.Hash(arg[1], arg[3])
+				}
 			}
 			return
 		}},
@@ -1008,68 +1033,44 @@ var Index = &ctx.Context{Name: "yac", Help: "语法中心",
 			}
 			return
 		}},
-		"for": &ctx.Command{Name: "for [[express ;] condition]|[index message meta value]",
+		"for": &ctx.Command{Name: "for exp | for index val... in list", Help: "循环语句",
-			Help: "循环语句, express: 每次循环运行的表达式, condition: 循环条件, index: 索引消息, message: 消息编号, meta: value: ",
 			Hand: func(m *ctx.Message, c *ctx.Context, key string, arg ...string) (e error) {
 				stack := m.Optionv("bio.stack").(*kit.Stack)
 				m.Log("stack", "push %v", stack.Push(arg[0], stack.Peek().Run && kit.Right(arg[1]), m.Optioni("stack.pos")).String("\\"))
 
-				/*
+				val, _ := stack.Hash(arg[len(arg)-1])
-					if cli, ok := m.Target().Server.(*YAC); m.Assert(ok) {
+				index := kit.Int(stack.FS[len(stack.FS)-2].Hash["_index"])
-						run := m.Caps("parse")
+				switch val := val.(type) {
-						defer func() { m.Caps("parse", run) }()
+				case map[string]interface{}:
-
+					list := make([]string, 0, len(val))
-						msg := m
+					for k, _ := range val {
-						if run {
+						list = append(list, k)
-							if arg[1] == "index" {
-								if code, e := strconv.Atoi(arg[2]); m.Assert(e) {
-									msg = m.Target().Message().Tree(code)
-									run = run && msg != nil && msg.Meta != nil
-									switch len(arg) {
-									case 4:
-										run = run && len(msg.Meta) > 0
-									case 5:
-										run = run && len(msg.Meta[arg[3]]) > 0
-									}
-								}
-							} else {
-								run = run && kit.Right(arg[len(arg)-1])
-							}
-
-							if len(cli.stack) > 0 {
-								if frame := cli.stack[len(cli.stack)-1]; frame.key == "for" && frame.pos == m.Optioni("file_pos") {
-									if arg[1] == "index" {
-										frame.index++
-										if run = run && len(frame.list) > frame.index; run {
-											if len(arg) == 5 {
-												arg[3] = arg[4]
-											}
-											m.Cap(arg[3], frame.list[frame.index])
-										}
-									}
-									frame.run = run
-									return
-								}
-							}
-						}
-
-						cli.stack = append(cli.stack, &Frame{pos: m.Optioni("file_pos"), key: key, run: run, index: 0})
-						if m.Capi("level", 1); run && arg[1] == "index" {
-							frame := cli.stack[len(cli.stack)-1]
-							switch len(arg) {
-							case 4:
-								frame.list = []string{}
-								for k, _ := range msg.Meta {
-									frame.list = append(frame.list, k)
-								}
-							case 5:
-								frame.list = msg.Meta[arg[3]]
-								arg[3] = arg[4]
-							}
-							m.Cap(arg[3], arg[3], frame.list[0], "临时变量")
-						}
 					}
-				*/
+					sort.Strings(list)
+
+					if index < len(list) {
+						stack.Hash(arg[1], list[index])
+					}
+					stack.Peek().Run = false
+					for i, j := 2, index; i < len(arg)-2 && j < len(list); i, j = i+1, j+1 {
+						stack.Peek().Run = true
+						stack.Hash(arg[i], val[list[j]])
+						stack.FS[len(stack.FS)-2].Hash["_index"] = j + 1
+					}
+
+				case []interface{}:
+					stack.Hash(arg[1], index)
+					stack.Peek().Run = false
+					for i, j := 2, index; i < len(arg)-2 && j < len(val); i, j = i+1, j+1 {
+						stack.Peek().Run = true
+						stack.Hash(arg[i], val[j])
+						stack.FS[len(stack.FS)-2].Hash["_index"] = j + 1
+					}
+				default:
+				}
+				if !stack.Peek().Run {
+					stack.FS[len(stack.FS)-2].Hash["_index"] = 0
+				}
 				return
 			}},
 		"fun": &ctx.Command{Name: "fun", Help: "", Hand: func(m *ctx.Message, c *ctx.Context, key string, arg ...string) (e error) {

src/plugin/favor/index.shy

@@ -34,36 +34,15 @@ fun salary "工资单" "" "" \
 
     let tax = 0
     let rest = $get
-    if $rest > 85000
+    let list = [85000 45 60000 35 40000 30 30000 25 17000 20 8000 10 5000 3]
-        let tax = $tax + ($rest - 85000) * 45 / 100
+    for i amount percent in list
-        let rest = 85000
+        if $rest > $amount
-    end
+            let tax = $tax + ($rest - $amount) * $percent / 100
-    if $rest > 60000
+            let rest = $amount
-        let tax = $tax + ($rest - 60000) * 35 / 100
+        end
-        let rest = 60000
-    end
-    if $rest > 40000
-        let tax = $tax + ($rest - 40000) * 30 / 100
-        let rest = 40000
-    end
-    if $rest > 30000
-        let tax = $tax + ($rest - 30000) * 25 / 100
-        let rest = 30000
-    end
-    if $rest > 17000
-        let tax = $tax + ($rest - 17000) * 20 / 100
-        let rest = 17000
-    end
-    if $rest > 8000
-        let tax = $tax + ($rest - 8000) * 10 / 100
-        let rest = 8000
-    end
-    if $rest > 5000
-        let tax = $tax + ($rest - 5000) * 3 / 100
     end
     let rest = $get - $tax
 
-
     append "公积金" $house
     append "养老保险" $old
     append "医疗保险" $tread

src/toolkit/shy.go

@@ -25,47 +25,47 @@ var bottom = &Frame{}
 
 type Stack struct {
 	Target interface{}
-	fs     []*Frame
+	FS     []*Frame
 }
 
 func (s *Stack) Push(key string, run bool, pos int) *Frame {
-	s.fs = append(s.fs, &Frame{Key: key, Run: run, Pos: pos, deep: len(s.fs), Hash: map[string]interface{}{}})
+	s.FS = append(s.FS, &Frame{Key: key, Run: run, Pos: pos, deep: len(s.FS), Hash: map[string]interface{}{}})
-	return s.fs[len(s.fs)-1]
+	return s.FS[len(s.FS)-1]
 }
 func (s *Stack) Peek() *Frame {
-	if len(s.fs) == 0 {
+	if len(s.FS) == 0 {
 		return bottom
 	}
-	return s.fs[len(s.fs)-1]
+	return s.FS[len(s.FS)-1]
 }
 func (s *Stack) Pop() *Frame {
-	if len(s.fs) == 0 {
+	if len(s.FS) == 0 {
 		return bottom
 	}
-	f := s.fs[len(s.fs)-1]
+	f := s.FS[len(s.FS)-1]
-	s.fs = s.fs[:len(s.fs)-1]
+	s.FS = s.FS[:len(s.FS)-1]
 	return f
 }
 func (s *Stack) Hash(key string, val ...interface{}) (interface{}, bool) {
-	for i := len(s.fs) - 1; i >= 0; i-- {
+	for i := len(s.FS) - 1; i >= 0; i-- {
-		if v, ok := s.fs[i].Hash[key]; ok {
+		if v, ok := s.FS[i].Hash[key]; ok {
 			if len(val) > 0 {
-				s.fs[i].Hash[key] = val[0]
+				s.FS[i].Hash[key] = val[0]
 			}
 			return v, ok
 		}
 	}
 
 	if len(val) > 0 {
-		s.fs[len(s.fs)-1].Hash[key] = val[0]
+		s.FS[len(s.FS)-1].Hash[key] = val[0]
 		return val[0], true
 	}
 	return nil, false
 }
 func (s *Stack) Label(key string) (int, bool) {
-	for i := len(s.fs) - 1; i >= 0; i-- {
+	for i := len(s.FS) - 1; i >= 0; i-- {
-		if v, ok := s.fs[i].Label[key]; ok {
+		if v, ok := s.FS[i].Label[key]; ok {
-			s.fs = s.fs[:i+1]
+			s.FS = s.FS[:i+1]
 			return v, ok
 		}
 	}