opt stack

base/ctx/ctx.go

@@ -9,10 +9,6 @@ const CTX = "ctx"
 
 var Index = &ice.Context{Name: CTX, Help: "标准模块"}
 
-func init() {
+func init() { ice.Index.Register(Index, nil, CONTEXT, COMMAND, CONFIG) }
-	ice.Index.Register(Index, nil, CONTEXT, COMMAND, CONFIG)
+
-	ice.Info.Stack[Prefix()] = func(m *ice.Message, key string, arg ...ice.Any) ice.Any {
-		return nil
-	}
-}
 func Prefix(arg ...string) string { return kit.Keys(CTX, arg) }

base/nfs/dir.go

@@ -201,12 +201,15 @@ func Relative(m *ice.Message, p string) string {
 	return p
 }
 func SplitPath(m *ice.Message, p string) []string {
+	line := kit.Select("1", strings.Split(p, ice.DF), 1)
+	p = strings.TrimPrefix(p, kit.Path("")+ice.PS)
+	p = strings.Split(p, ice.DF)[0]
 	if ls := kit.Split(kit.Select(ice.SRC_MAIN_GO, p), ice.PS); len(ls) == 1 {
-		return []string{PWD, ls[0]}
+		return []string{PWD, ls[0], line}
 	} else if ls[0] == ice.USR {
-		return []string{strings.Join(ls[:2], ice.PS) + ice.PS, strings.Join(ls[2:], ice.PS)}
+		return []string{strings.Join(ls[:2], ice.PS) + ice.PS, strings.Join(ls[2:], ice.PS), line}
 	} else {
-		return []string{strings.Join(ls[:1], ice.PS) + ice.PS, strings.Join(ls[1:], ice.PS)}
+		return []string{strings.Join(ls[:1], ice.PS) + ice.PS, strings.Join(ls[1:], ice.PS), line}
 	}
 }
 func Dir(m *ice.Message, field string) *ice.Message {

base/tcp/host.go

@@ -88,21 +88,15 @@ func IsLocalHost(m *ice.Message, ip string) bool         { return m.Cmdx(HOST, I
 func PublishLocalhost(m *ice.Message, url string) string { return m.Cmdx(HOST, PUBLISH, url) }
 
 func init() {
-	ice.Info.Stack[Prefix()] = func(m *ice.Message, key string, arg ...ice.Any) ice.Any {
+	ice.Info.Stack[Prefix(IsLocalHost)] = func(m *ice.Message, key string, arg ...ice.Any) ice.Any {
-		switch key {
+		for _, v := range arg {
-		case kit.FuncName(IsLocalHost):
+			switch v := v.(type) {
-			for _, v := range arg {
+			case *ice.Message:
-				switch v := v.(type) {
+				m = v
-				case *ice.Message:
+			case string:
-					m = v
+				return IsLocalHost(m, v)
-				case string:
-					return IsLocalHost(m, v)
-				}
 			}
-			return false
-		default:
-			m.ErrorNotImplement(key)
-			return nil
 		}
+		return false
 	}
 }

base/tcp/tcp.go

@@ -11,4 +11,4 @@ var Index = &ice.Context{Name: TCP, Help: "通信模块"}
 
 func init() { ice.Index.Register(Index, nil, HOST, PORT, CLIENT, SERVER) }
 
-func Prefix(arg ...string) string { return kit.Keys(TCP, kit.Keys(arg)) }
+func Prefix(arg ...ice.Any) string { return kit.Keys(TCP, kit.Keys(arg...)) }

base/yac/expr.go

@@ -26,16 +26,15 @@ const (
 	END    = "}"
 )
 
-var keyword = regexp.MustCompile(`[_a-zA-Z][_a-zA-Z0-9\.]*`)
-
 var level = map[string]int{
 	"//": 200, "/*": 200, "*/": 200,
-	"&": 100, // "*": 100, "!": 100,
+	"!": 100, "&": 100, // "*": 100,
 	"[": 100, "]": 100, "++": 100, "--": 100,
 	"*": 40, "/": 40, "+": 30, "-": 30,
 	"<": 20, ">": 20, ">=": 20, "<=": 20, "!=": 20, "==": 20, "&&": 10, "||": 10,
 	DEFS: 2, DEFINE: 2, ASSIGN: 2, FIELD: 2, OPEN: 1, CLOSE: 1,
 }
+var keyword = regexp.MustCompile(`^[_a-zA-Z.][_a-zA-Z0-9.]*$`)
 
 type Expr struct {
 	list ice.List
@@ -90,6 +89,15 @@ func (s *Expr) setv(m *ice.Message, p int, op string, v Any) Any {
 		return s.value(m, k, v, op)
 	}
 }
+func (s *Expr) isop(k Any) bool {
+	switch k := k.(type) {
+	case int:
+		return level[s.gets(k)] > 0
+	case string:
+		return level[k] > 0
+	}
+	return false
+}
 func (s *Expr) opv(m *ice.Message, p int, op string, v Any) Any {
 	if !s.runable() {
 		return s.getv(m, p)
@@ -103,7 +111,7 @@ func (s *Expr) ops(m *ice.Message) {
 	if !s.runable() || s.getl(-2) < 10 {
 		return
 	}
-	s.pops(3, s.opv(m, -3, s.gets(-2), s.getv(m, -1)))
+	s.pops(3, s.opv(m, -3, s.gets(-2), s.get(-1)))
 }
 func (s *Expr) end(m *ice.Message) Any {
 	if !s.runable() || len(s.list) == 0 {
@@ -122,14 +130,14 @@ func (s *Expr) end(m *ice.Message) Any {
 				}
 				s.list = append(s.list[:0], Value{list})
 			default:
-				s.list = append(s.list[:0], s.setv(m, -3, s.gets(-2), s.getv(m, -1)))
+				s.list = append(s.list[:0], s.setv(m, -3, s.gets(-2), s.get(-1)))
 			}
 		case FIELD:
 			list := kit.List()
 			for i := len(s.list) - 2; i > 0; i -= 2 {
 				if s.gets(i) == DEFINE || s.gets(i) == ASSIGN {
 					for j := 0; j < i; j += 2 {
-						list = append(list, s.setv(m, j, s.gets(i), s.getv(m, j+i+1)))
+						list = append(list, s.setv(m, j, s.gets(i), s.get(j+i+1)))
 					}
 					s.list = append(s.list[:0], Value{list})
 					break
@@ -145,49 +153,41 @@ func (s *Expr) end(m *ice.Message) Any {
 	}
 	return s.getv(m, 0)
 }
-func (s *Expr) isop(k Any) bool {
-	switch k := k.(type) {
-	case int:
-		return level[s.gets(k)] > 0
-	case string:
-		return level[k] > 0
-	}
-	return false
-}
-
 func (s *Expr) sub(m *ice.Message) *Expr {
 	sub := NewExpr(s.Stack)
 	sub.n = s.n + 1
 	return sub
 }
-func (s *Expr) ktv(m *ice.Message, ismap bool, t Any, p string) map[string]Any {
+func (s *Expr) ktv(m *ice.Message, t Any, p string) map[string]Any {
+	var kt, vt Any
+	switch t := t.(type) {
+	case Map:
+		kt, vt = s.types(m, t.key, p), s.types(m, t.value, p)
+	}
 	data := kit.Dict()
 	for s.token() != END {
 		k := ""
-		kit.If(ismap, func() {
+		kit.If(t == nil || kt != nil, func() {
 			sub := s.sub(m)
-			if k = kit.Format(Trans(sub.cals(m, DEFS, END))); k == "" {
+			sub.t, sub.p = kt, p
-				k = _parse_const(m, sub.gets(0))
+			k = kit.Format(Trans(sub.cals(m, DEFS, END)))
-			}
 		}, func() {
 			k = s.next(m)
 			kit.If(s.token() != END, func() { s.next(m) })
 		})
 		kit.If(s.token() == DEFS, func() {
 			sub := s.sub(m)
-			if sub.p = p; ismap {
+			if sub.p = p; t == nil || kt != nil {
-				sub.t = t
+				sub.t = vt
 			} else {
 				switch t := t.(type) {
 				case Struct:
-					if field, ok := t.index[k].(Field); ok {
+					sub.t = t.index[k].(Field)
-						sub.t = field.kind
-					}
 				}
 			}
-			m.Debug("field %d %#v %#v", sub.n, k, sub.t)
+			m.Debug("field %d %s %s", sub.n, k, Format(sub.t))
 			data[k] = sub.cals(m, FIELD, END)
-			m.Debug("field %d %#v %#v", sub.n, k, data[k])
+			m.Debug("field %d %s %s", sub.n, k, Format(data[k]))
 		})
 	}
 	return data
@@ -197,8 +197,9 @@ func (s *Expr) ntv(m *ice.Message, t Any, p string) []Any {
 	for !kit.IsIn(s.token(), SUPS, END) {
 		sub := s.sub(m)
 		sub.t, sub.p = t, p
+		m.Debug("field %d %d %s", sub.n, len(data), Format(sub.t))
 		if v := sub.cals(m, FIELD, SUPS, END); v != nil {
-			m.Debug("field %d %d %#v", sub.n, len(data), v)
+			m.Debug("field %d %d %s", sub.n, len(data), Format(v))
 			data = append(data, v)
 		}
 	}
@@ -222,7 +223,6 @@ func (s *Expr) cals(m *ice.Message, arg ...string) Any {
 		if kit.IsIn(k, arg...) {
 			return true
 		}
-		m.Debug("what %v", k)
 		switch k {
 		case SPLIT:
 			return true
@@ -231,28 +231,28 @@ func (s *Expr) cals(m *ice.Message, arg ...string) Any {
 			kit.If(strings.Contains(s.gets(-1), ice.PT), func() { p = kit.Split(s.gets(-1), ice.PT)[0] })
 			switch t := s.getv(m, -1).(type) {
 			case Map:
-				s.pops(1, Dict{s.ktv(m, true, s.value(m, kit.Keys(p, t.value)), p)})
+				s.pops(1, Dict{s.ktv(m, t, p)})
 				return false
 			case Slice:
 				s.pops(1, List{s.ntv(m, t, p)})
 				return false
 			case Struct:
-				s.pops(1, Object{Dict{s.ktv(m, false, t, p)}, t})
+				s.pops(1, Object{Dict{s.ktv(m, t, p)}, t})
 				return false
 			}
 			switch t := s.t.(type) {
 			case Map:
-				s.pops(0, Dict{s.ktv(m, true, s.value(m, kit.Keys(s.p, t.value)), s.p)})
+				s.pops(0, Dict{s.ktv(m, t.value, s.p)})
 				return false
 			case Slice:
 				s.pops(0, List{s.ntv(m, t, s.p)})
 				return false
 			case Struct:
-				s.pops(0, Object{Dict{s.ktv(m, false, t, s.p)}, t})
+				s.pops(0, Object{Dict{s.ktv(m, t, s.p)}, t})
 				return false
 			}
 			if kit.IsIn(s.gets(-1), DEFINE) || len(s.list) == 0 && len(arg) > 0 {
-				s.pops(0, Dict{s.ktv(m, true, nil, "")})
+				s.pops(0, Dict{s.ktv(m, s.t, s.p)})
 				return false
 			}
 			return true
@@ -260,42 +260,23 @@ func (s *Expr) cals(m *ice.Message, arg ...string) Any {
 			s.skip--
 			return true
 		case MAP:
-			s.next(m)
+			s.push(s.Stack.types(m))
-			key := s.next(m)
-			s.next(m)
-			value := s.next(m)
-			v := Map{key: key, value: value}
-			name := kit.Format("map[%s]%s", v.key, v.value)
-			s.value(m, name, v)
-			s.push(name)
 			return false
 		case SUBS:
-			if s.peek(m) == SUPS {
+			if s.peek(m) == SUPS && !kit.IsIn(kit.Select("", s.rest, s.skip+2), FIELD, SUPS, END, "") {
-				pos := s.Position
+				s.push(s.Stack.types(m))
-				if s.next(m); !s.isop(s.peek(m)) {
+				return false
-					v := Slice{value: s.next(m)}
-					name := kit.Format("[]%s", v.value)
-					s.value(m, name, v)
-					s.push(name)
-					return false
-				}
-				s.Position = pos
 			}
 			if kit.IsIn(s.gets(-1), DEFINE) || len(s.list) == 0 && len(arg) > 0 {
-				s.push(List{s.ntv(m, nil, "")})
+				s.push(List{s.ntv(m, s.t, s.p)})
 				return false
 			}
 		case STRUCT, INTERFACE:
-			s.skip--
+			s.push(s.Stack.types(m))
-			name := s.show()
-			s.rest[s.skip] = name
-			s.skip--
-			m.Cmd(TYPE)
-			s.push(name)
 			return false
 		case FUNC:
-			if s.isop(-1) || len(s.list) == 0 {
+			if s.skip > 0 {
-				s.push(s.value(m, s.funcs(m)))
+				s.push(s.funcs(m, ""))
 				return false
 			}
 			s.skip--
@@ -309,33 +290,51 @@ func (s *Expr) cals(m *ice.Message, arg ...string) Any {
 		}
 		if len(s.list) > 0 && !s.isop(-1) {
 			switch k {
+			case OPEN:
+				if strings.HasSuffix(s.gets(-1), ice.PT) {
+					if s.peek(m) == TYPE {
+						switch v := s.getv(m, -1).(type) {
+						case Object:
+							s.pops(1, v.index)
+						default:
+							s.pops(1, kit.Format("%T", v))
+						}
+					} else {
+						switch t := s.sub(m).cals(m, CLOSE).(type) {
+						case Struct:
+							if v, ok := s.get(-1).(Operater); ok {
+								s.pops(1, Value{list: []Any{v, v.Operate(INSTANCEOF, t)}})
+							}
+						case Interface:
+							if v, ok := s.get(-1).(Operater); ok {
+								s.pops(1, Value{list: []Any{v, v.Operate(IMPLEMENTS, t)}})
+							}
+						}
+					}
+					return false
+				}
+				switch k := s.get(-1).(type) {
+				case string:
+					s.pops(1, s.call(m, s.Stack, k))
+				default:
+					s.pops(1, s.call(m, k, ""))
+				}
+				return false
 			case SUBS:
 				switch v := s.sub(m).cals(m, SUPS); s.get(-1).(type) {
 				case string:
-					m.Debug("what %v %v", s.gets(-1), Trans(v))
 					s.pops(1, kit.Keys(s.gets(-1), kit.Format(Trans(v))))
 				default:
-					m.Debug("what %v %v", s.get(-1), v)
 					s.pops(1, s.opv(m, -1, SUBS, v))
 				}
 				return false
-			case OPEN:
-				switch k := s.get(-1).(type) {
-				case string:
-					m.Debug("call %v", k)
-					s.pops(1, s.call(m, s.Stack, k))
-				default:
-					m.Debug("call %v", k)
-					s.pops(1, s.call(m, k, ""))
-				}
-				return false
 			case "++", "--":
 				s.pops(1, s.setv(m, -1, ASSIGN, s.opv(m, -1, k, nil)))
 				return false
 			}
 			if !s.isop(k) {
 				if strings.HasPrefix(k, ice.PT) {
-					if kit.Select("", s.rest, s.skip+1) == OPEN {
+					if s.peek(m) == OPEN {
 						s.skip++
 						s.pops(1, s.call(m, s.getv(m, -1), strings.TrimPrefix(k, ice.PT)))
 						return false
@@ -360,7 +359,6 @@ func (s *Expr) cals(m *ice.Message, arg ...string) Any {
 		}
 		return false
 	})
-	m.Debug("what %v", s.list)
 	if s.cmds(m, line) {
 		return nil
 	}
@@ -379,31 +377,31 @@ func (s *Expr) trans(m *ice.Message, k string) Any {
 		return Number{value: k}
 	}
 }
+func (s *Expr) types(m *ice.Message, t Any, p string) Any {
+	switch t := t.(type) {
+	case string:
+		if p == "" || kit.IsIn(t, STRING, INT) {
+			return t
+		}
+		return s.value(m, kit.Keys(p, t))
+	default:
+		return t
+	}
+}
 func (s *Expr) cmds(m *ice.Message, line int) (done bool) {
 	if len(s.list) == 1 && s.skip < 2 {
 		m.Search(s.gets(0), func(key string, cmd *ice.Command) {
 			args := kit.List(s.gets(0))
 			for done = true; s.line == line; {
-				sub := s.sub(m)
+				args = append(args, kit.Format(Trans(s.sub(m).cals(m))))
-				switch sub.cals(m); v := sub.get(0).(type) {
-				case string:
-					if _v := s.value(m, v); _v != nil {
-						args = append(args, kit.Format(Trans(_v)))
-					} else {
-						args = append(args, v)
-					}
-				default:
-					args = append(args, kit.Format(Trans(v)))
-				}
 			}
-			m.Cmdy(args...)
+			kit.If(s.runable(), func() { m.Cmdy(args...) })
 		})
 	}
 	return
 }
 func (s *Expr) call(m *ice.Message, obj Any, key string) Any {
-	v := s.sub(m).cals(m, CLOSE)
+	if arg := _parse_res(m, s.sub(m).cals(m, CLOSE)); s.runable() {
-	if arg := _parse_res(m, v); s.runable() {
 		return s.calls(m, obj, key, nil, arg...)
 	} else {
 		return nil
@@ -417,16 +415,16 @@ func init() {
 	Index.MergeCommands(ice.Commands{
 		EXPR: {Name: "expr a, b = 1, 2", Hand: func(m *ice.Message, arg ...string) {
 			s := _parse_stack(m)
-			if arg, v := s.rest, s.cals(m); !s.runable() {
+			if v := s.cals(m); !s.runable() {
 				return
 			} else if v != nil {
-				m.Debug("value %#v <- %v", v, arg)
+				m.Debug("value %s %s <- %v", Format(s), Format(v), arg)
 				switch v := Trans(v).(type) {
 				case Message:
 				case Value:
-					kit.If(len(v.list) > 0, func() { m.Echo(kit.Format(v.list[0])) })
+					kit.If(len(v.list) > 0, func() { m.Echo(kit.Format(Trans(v.list[0]))) })
 				default:
-					m.Echo(kit.Format(v))
+					m.Echo(kit.Format(Trans(v)))
 				}
 			} else if s.token() == BEGIN {
 				m.Echo(ice.TRUE)

base/yac/import.go

@@ -28,8 +28,8 @@ func init() {
 					s, f := _parse_frame(m)
 					defer s.popf(m)
 					kit.For(u.Query(), func(k string, v []string) { f.value[k] = v[0] })
-					sub := s.parse(m, p, r)
+					s.parse(m, p, r)
-					kit.If(pre != "_", func() { kit.For(sub.peekf().value, func(k string, v Any) { s.frame[0].value[kit.Keys(pre, k)] = v }) })
+					kit.If(pre != "_", func() { kit.For(f.value, func(k string, v Any) { s.frame[0].value[kit.Keys(pre, k)] = v }) })
 				}
 			}
 			find := func(pre, url string) {

base/yac/stack.go

@@ -8,11 +8,15 @@ import (
 	"strings"
 
 	ice "shylinux.com/x/icebergs"
+	"shylinux.com/x/icebergs/base/ctx"
 	"shylinux.com/x/icebergs/base/mdb"
 	"shylinux.com/x/icebergs/base/nfs"
 	kit "shylinux.com/x/toolkits"
 )
 
+type Value struct {
+	list []Any
+}
 type Function struct {
 	obj []Field
 	arg []Field
@@ -20,16 +24,19 @@ type Function struct {
 	Position
 	object Object
 }
+
 type Frame struct {
 	key    string
+	name   string
 	value  ice.Map
 	defers []func()
 	status int
 	Position
 }
 type Stack struct {
-	last  *Frame
+	last    *Frame
-	frame []*Frame
+	frame   []*Frame
+	comment []string
 	Position
 }
 type Position struct {
@@ -45,11 +52,11 @@ type Buffer struct {
 }
 
 func (s *Stack) peekf() *Frame { return s.frame[len(s.frame)-1] }
-func (s *Stack) pushf(m *ice.Message, key string) *Frame {
+func (s *Stack) pushf(m *ice.Message, arg ...string) *Frame {
-	f := &Frame{key: kit.Select(m.CommandKey(), key), value: kit.Dict(), Position: s.Position}
+	f := &Frame{key: kit.Select(m.CommandKey(), arg, 0), name: kit.Select("", arg, 1), value: kit.Dict(), Position: s.Position}
 	kit.If(len(s.frame) > 0, func() { f.status = s.peekf().status })
-	m.Debug("stack %d push %s %s", len(s.frame), f.key, s.show())
 	s.frame = append(s.frame, f)
+	m.Debug("stack %s push %s", Format(s), kit.Select(s.show(), arg, 2))
 	return f
 }
 func (s *Stack) popf(m *ice.Message) *Frame {
@@ -57,7 +64,7 @@ func (s *Stack) popf(m *ice.Message) *Frame {
 	for i := len(f.defers) - 1; i >= 0; i-- {
 		f.defers[i]()
 	}
-	m.Debug("stack %d pop %s %s", len(s.frame)-1, f.key, s.show())
+	m.Debug("stack %s pop %s", Format(s), s.show())
 	kit.If(len(s.frame) > 0, func() { s.frame = s.frame[:len(s.frame)-1] })
 	s.last = f
 	return f
@@ -70,25 +77,28 @@ func (s *Stack) stack(cb func(*Frame, int) bool) {
 	}
 }
 func (s *Stack) value(m *ice.Message, key string, arg ...Any) Any {
+	keys := strings.Split(key, ice.PT)
 	f, n := s.peekf(), len(s.frame)-1
 	if len(arg) < 2 || arg[1] != DEFINE {
 		s.stack(func(_f *Frame, i int) bool {
-			if _f.value[key] != nil {
+			if _f.value[key] != nil || _f.value[keys[0]] != nil {
 				f, n = _f, i
 				return true
 			}
 			return false
 		})
 	}
-	keys := strings.Split(key, ice.PT)
-	kit.If(strings.Contains(key, ice.PS), func() { keys = []string{key} })
 	kit.If(len(arg) > 0, func() {
+		if f.value[key] != nil {
+			f.value[key] = arg[0]
+			return
+		}
 		var v Any = Dict{f.value}
 		for i := 0; i < len(keys); i++ {
 			switch k := keys[i]; _v := v.(type) {
 			case Operater:
 				if i == len(keys)-1 {
-					m.Debug("value %d:%s set %v %#v", n, f.key, key, arg[0])
+					m.Debug("value %d:%s set %s %s", n, f.key, key, Format(arg[0]))
 					_v.Operate(k, arg[0])
 				} else {
 					if v = _v.Operate(SUBS, k); v == nil {
@@ -104,53 +114,30 @@ func (s *Stack) value(m *ice.Message, key string, arg ...Any) Any {
 			}
 		}
 	})
-	v, ok := f.value[key]
+	if v, ok := f.value[key]; ok {
-	if ok {
 		return v
-	} else {
-		if s.stack(func(_f *Frame, i int) bool {
-			v, ok = _f.value[key]
-			return ok
-		}); ok {
-			return v
-		}
 	}
-	v = s
+	var v Any = Dict{f.value}
 	kit.For(keys, func(k string) {
-		m.Debug("what %#v %v", v, k)
 		switch _v := v.(type) {
 		case Operater:
 			v = _v.Operate(SUBS, k)
-		case *Stack:
-			v = nil
-			_v.stack(func(_f *Frame, i int) bool {
-				v, ok = _f.value[k]
-				return ok
-			})
 		default:
 			v = nil
 		}
 	})
 	if v != nil {
 		return v
+	} else if v = _parse_const(m, key); v != "" {
+		return v
 	}
-	return _parse_const(m, key)
+	return nil
 }
 func (s *Stack) runable() bool { return s.peekf().status > STATUS_DISABLE }
 func (s *Stack) token() string { return kit.Select("", s.rest, s.skip) }
-func (s *Stack) show() string {
+func (s *Stack) show() string  { return Format(s.Position) }
-	if s.Buffer == nil {
-		return ""
-	} else if s.skip == -1 {
-		return kit.Format("%s:%d", s.name, s.line+1)
-	} else {
-		return kit.Format("%s:%d:%d", s.name, s.line+1, s.skip)
-	}
-}
 func (s *Stack) read(m *ice.Message) (text string, ok bool) {
-	isvoid := func(text string) bool {
+	isvoid := func(text string) bool { return strings.TrimSpace(text) == "" }
-		return strings.TrimSpace(text) == "" || strings.HasPrefix(strings.TrimSpace(text), "#")
-	}
 	for s.line++; s.line < len(s.list); s.line++ {
 		if isvoid(s.list[s.line]) {
 			continue
@@ -169,9 +156,10 @@ func (s *Stack) read(m *ice.Message) (text string, ok bool) {
 }
 func (s *Stack) reads(m *ice.Message, cb func(k string) bool) {
 	block, last := []string{}, 0
+	comment := false
 	for {
 		if s.skip++; s.skip < len(s.rest) {
-			if k := s.rest[s.skip]; k == "`" {
+			if k, v := s.rest[s.skip], kit.Select("", s.rest, s.skip+1); k == "`" {
 				if len(block) > 0 {
 					kit.If(s.line != last, func() { block, last = append(block, ice.NL), s.line })
 					block = append(block, k)
@@ -180,18 +168,27 @@ func (s *Stack) reads(m *ice.Message, cb func(k string) bool) {
 				} else {
 					block = append(block, k)
 				}
-				continue
 			} else if len(block) > 0 {
 				kit.If(s.line != last, func() { block, last = append(block, ice.NL), s.line })
 				block = append(block, k)
-				continue
+			} else if k == "*" && v == ice.PS {
-			}
+				comment = false
-			if s.rest[s.skip] == ice.PS && kit.Select("", s.rest, s.skip+1) == ice.PS {
+				s.skip++
+			} else if comment {
+
+			} else if k == ice.PS && v == "*" {
+				comment = true
+				s.skip++
+			} else if k == ice.PS && v == ice.PS {
+				s.comment = append(s.comment, s.list[s.line])
 				s.skip = len(s.rest)
-				continue
+			} else if s.skip == 0 && strings.HasPrefix(k, "#") {
-			}
+				s.comment = append(s.comment, s.list[s.line])
-			if cb(s.rest[s.skip]) {
+				s.skip = len(s.rest)
+			} else if cb(s.rest[s.skip]) {
 				break
+			} else {
+				s.comment = s.comment[:0]
 			}
 		} else if text, ok := s.read(m); ok {
 			s.rest, s.skip = kit.Split(text, SPACE, BLOCK, QUOTE, TRANS, ice.TRUE), -1
@@ -235,9 +232,9 @@ func (s *Stack) run(m *ice.Message) {
 			m.Cmdy(k, kit.Slice(s.rest, s.skip+1))
 		} else {
 			if s.skip--; s.skip == -1 {
-				m.Cmd(EXPR, s.rest, ice.SP, s.show())
+				m.Cmd(EXPR, s.rest)
 			} else {
-				m.Cmd(EXPR, kit.Slice(s.rest, s.skip), ice.SP, s.show())
+				m.Cmd(EXPR, kit.Slice(s.rest, s.skip))
 			}
 		}
 		return false
@@ -259,7 +256,6 @@ func (s *Stack) cals0(m *ice.Message, arg ...string) string {
 func (s *Stack) types(m *ice.Message) Any {
 	for ; s.skip < len(s.rest); s.skip++ {
 		switch s.token() {
-		case "*":
 		case MAP:
 			s.skip += 2
 			key := s.types(m)
@@ -276,8 +272,10 @@ func (s *Stack) types(m *ice.Message) Any {
 				}
 				types := s.types(m)
 				kit.For(key, func(key string) {
-					field := Field{key, types}
+					field := Field{types, map[string]string{}, key}
-					t.field = append(t.field, field)
+					if strings.HasSuffix(s.list[s.line], "`") {
+						kit.For(kit.Split(kit.Select("", kit.Split(s.list[s.line]), -1), ": "), func(k, v string) { field.tags[k] = v })
+					}
 					t.index[key] = field
 				})
 				key, s.skip = key[:0], len(s.rest)
@@ -287,90 +285,70 @@ func (s *Stack) types(m *ice.Message) Any {
 			t := Interface{index: map[string]Function{}}
 			for s.next(m); s.next(m) != END; {
 				name := s.token()
-				field, list := Field{}, [][]Field{}
+				s.rest[s.skip] = FUNC
-				for s.skip++; s.skip < len(s.rest); s.skip++ {
+				t.index[name] = s.types(m).(Function)
-					switch s.token() {
-					case OPEN:
-						list = append(list, []Field{})
-					case "*":
-					case FIELD, CLOSE:
-						list[len(list)-1] = append(list[len(list)-1], field)
-						field = Field{}
-					default:
-						switch t := s.types(m).(type) {
-						case string:
-							kit.If(field.name == "", func() { field.name = t }, func() { field.kind = t })
-						default:
-							field.kind = s.types(m)
-						}
-					}
-				}
-				kit.If(len(list) == 1, func() { list = append(list, []Field{}) })
-				t.index[name] = Function{arg: list[0], res: list[1]}
-				s.skip = len(s.rest)
 			}
 			return t
 		case FUNC:
 			field, list := Field{}, [][]Field{}
-			for s.skip++; s.skip < len(s.rest); s.skip++ {
+			for s.skip++; s.skip < len(s.rest) && s.token() != BEGIN; s.skip++ {
 				switch s.token() {
 				case OPEN:
 					list = append(list, []Field{})
-				case "*":
 				case FIELD, CLOSE:
 					list[len(list)-1] = append(list[len(list)-1], field)
 					field = Field{}
+				case "*":
 				default:
 					switch t := s.types(m).(type) {
 					case string:
-						kit.If(field.name == "", func() { field.name = t }, func() { field.kind = t })
+						kit.If(field.name == "", func() { field.name = t }, func() { field.types = t })
 					default:
-						field.kind = s.types(m)
+						field.types = s.types(m)
 					}
 				}
 			}
 			kit.If(len(list) == 1, func() { list = append(list, []Field{}) })
 			return Function{arg: list[0], res: list[1]}
+		case "*":
 		default:
-			// if t := s.value(m, s.token()); t != nil && t != "" {
-			// 	return t
-			// }
 			return s.token()
 		}
 	}
-	return ""
+	return nil
 }
-func (s *Stack) funcs(m *ice.Message) string {
+func (s *Stack) funcs(m *ice.Message, name string) Function {
-	name := s.show()
+	v := s.types(m).(Function)
-	s.rest[s.skip], s.skip = name, s.skip-1
+	if f := s.pushf(m, FUNC, name); name == INIT {
-	m.Cmd(FUNC, name)
+		f.key = CALL
-	f := s.peekf()
+	} else {
-	status := f.status
+		f.status = STATUS_DISABLE
-	defer func() { f.status = status }()
-	f.status = STATUS_DISABLE
-	s.run(m)
-	return name
-}
-func (s *Stack) calls(m *ice.Message, obj Any, key Any, cb func(*Frame, Function), arg ...Any) Any {
-	m.Debug("stack %d call %T %s %#v", len(s.frame)-1, obj, key, arg)
-	if _k, ok := key.(string); ok && _k != "" {
-		kit.For(kit.Split(_k, ice.PT), func(k string) {
-			switch v := obj.(type) {
-			case Operater:
-				obj = v.Operate(SUBS, k)
-			case *Stack:
-				if _v := v.value(m, _k); _v != nil && _v != "" {
-					obj, key = _v, ""
-				} else {
-					obj, key = v.value(m, k), strings.TrimPrefix(_k, k+ice.PT)
-				}
-			}
-		})
 	}
+	v.Position = s.Position
+	s.run(m)
+	return v
+}
+func (s *Stack) calls(m *ice.Message, obj Any, key string, cb func(*Frame, Function), arg ...Any) Any {
+	m.Debug("calls %s %T %s(%s)", Format(s), obj, key, Format(arg...))
+	switch v := obj.(type) {
+	case *Stack:
+		if _v := v.value(m, key); _v != nil {
+			obj, key = _v, ""
+		}
+	}
+	kit.For(kit.Split(key, ice.PT), func(k string) {
+		switch v := obj.(type) {
+		case Operater:
+			obj, key = v.Operate(SUBS, k), strings.TrimPrefix(strings.TrimPrefix(key, k), ice.PT)
+		case *Stack:
+			obj, key = v.value(m, k), strings.TrimPrefix(strings.TrimPrefix(key, k), ice.PT)
+		}
+	})
 	switch obj := obj.(type) {
 	case Function:
-		m.Debug("stack %d call %T %s %#v", len(s.frame)-1, obj, kit.Select("", obj.obj, -1), arg)
+		name := kit.Format("%s%s", kit.Select("", kit.Format("%s.", obj.obj[0].types), len(obj.obj) > 1), obj.obj[len(obj.obj)-1].name)
-		f := s.pushf(m, CALL)
+		m.Debug("calls %s %s(%s) %s", Format(s), name, Format(arg...), Format(obj.Position))
+		f := s.pushf(m, CALL, name, Format(obj.Position))
 		for _, field := range obj.res {
 			f.value[field.name] = nil
 		}
@@ -397,15 +375,15 @@ func (s *Stack) calls(m *ice.Message, obj Any, key Any, cb func(*Frame, Function
 			s.Position = pos
 		})
 		kit.If(cb != nil, func() { cb(f, obj) })
-		s.run(m.Options(ice.YAC_STACK, s))
+		s.run(m)
 		return value
 	case Caller:
-		m.Debug("stack %d call %T %s %#v", len(s.frame)-1, obj, key, arg)
 		kit.For(arg, func(i int, v Any) { arg[i] = Trans(arg[i]) })
+		m.Debug("calls %s %s.%s(%s)", Format(s), Format(obj), key, Format(arg...))
 		return wrap(obj.Call(kit.Format(key), arg...))
 	case func(*ice.Message, string, ...Any) Any:
-		m.Debug("stack %d call %s %s %#v", len(s.frame)-1, kit.FileLine(obj, 3), key, arg)
 		kit.For(arg, func(i int, v Any) { arg[i] = Trans(arg[i]) })
+		m.Debug("calls %s %s %s %s", Format(s), Format(obj), key, Format(arg...))
 		return wrap(obj(m, kit.Format(key), arg...))
 	case func():
 		obj()
@@ -414,18 +392,13 @@ func (s *Stack) calls(m *ice.Message, obj Any, key Any, cb func(*Frame, Function
 		if key == "" {
 			return nil
 		}
-		m.Debug("stack %d call %T %s %#v", len(s.frame)-1, obj, key, arg)
 		args := kit.List(key)
 		kit.For(arg, func(i int, v Any) { args = append(args, Trans(v)) })
+		m.Debug("calls %s %s", Format(s), Format(args...))
 		return Message{m.Cmd(args...)}
 	}
 }
-func (s *Stack) Handler(obj Any) ice.Handler {
+func (s *Stack) Action(m *ice.Message, obj Any, key string, arg ...string) *ice.Message {
-	return func(m *ice.Message, arg ...string) {
-		m.Copy(s.Action(m.Spawn(Index).Spawn(m.Target()), obj, nil, arg...))
-	}
-}
-func (s *Stack) Action(m *ice.Message, obj Any, key Any, arg ...string) *ice.Message {
 	s.calls(m, obj, key, func(f *Frame, v Function) {
 		i := 0
 		for _, field := range v.arg {
@@ -443,18 +416,23 @@ func (s *Stack) Action(m *ice.Message, obj Any, key Any, arg ...string) *ice.Mes
 	})
 	return m
 }
+func (s *Stack) Handler(obj Any) ice.Handler {
+	return func(m *ice.Message, arg ...string) {
+		m.Copy(s.Action(m.Options(ice.YAC_STACK, s).Spawn(Index).Spawn(m.Target()), obj, "", arg...))
+	}
+}
 func (s *Stack) parse(m *ice.Message, name string, r io.Reader) *Stack {
 	pos := s.Position
 	defer func() { s.Position = pos }()
 	s.Position = Position{Buffer: &Buffer{name: name, input: bufio.NewScanner(r)}}
 	s.peekf().Position = s.Position
-	m.Debug("stack %d parse %s", len(s.frame)-1, s.show())
+	m.Debug("stack %s parse %s", Format(s), s.show())
 	s.run(m)
 	return s
 }
-func NewStack(m *ice.Message, cb func(*Frame)) *Stack {
+func NewStack(m *ice.Message, cb func(*Frame), arg ...string) *Stack {
 	s := &Stack{}
-	s.pushf(m.Options(ice.YAC_STACK, s), STACK)
+	s.pushf(m.Options(ice.YAC_STACK, s), kit.Simple(STACK, arg)...)
 	s.load(m, cb)
 	return s
 }
@@ -490,17 +468,17 @@ const STACK = "stack"
 
 func init() {
 	Index.MergeCommands(ice.Commands{
-		STACK: {Name: "stack path auto parse", Actions: ice.Actions{
+		STACK: {Name: "stack path auto parse", Actions: ice.MergeActions(ice.Actions{
 			"start": {Hand: func(m *ice.Message, arg ...string) {}},
-			ice.CMD: {Hand: func(m *ice.Message, arg ...string) {}},
+		}, ctx.CmdAction()), Hand: func(m *ice.Message, arg ...string) {
-			ice.RUN: {Hand: func(m *ice.Message, arg ...string) {}},
-		}, Hand: func(m *ice.Message, arg ...string) {
 			if len(arg) == 0 || strings.HasSuffix(arg[0], ice.PS) {
 				m.Options(nfs.DIR_ROOT, nfs.SRC).Cmdy(nfs.CAT, arg)
 				return
 			}
 			nfs.Open(m, path.Join(nfs.SRC, strings.TrimPrefix(path.Join(arg...), nfs.SRC)), func(r io.Reader, p string) {
-				if NewStack(m, nil).parse(m, p, r); m.Option(ice.DEBUG) == ice.TRUE {
+				s := NewStack(m, nil, "", p).parse(m, p, r)
+				if m.StatusTime(mdb.LINK, s.value(m, "_link")); m.Option(ice.DEBUG) == ice.TRUE {
+					m.Option("__index", kit.Format(s.value(m, "_index")))
 					m.Cmdy(INFO, arg)
 				}
 			})
@@ -549,11 +527,10 @@ func StackHandler(m *ice.Message, arg ...string) {
 				kit.If(!kit.IsIn(field.name, "m", "msg", ice.ARG), func() { list = append(list, kit.Dict(mdb.NAME, field.name, mdb.TYPE, mdb.TEXT, mdb.VALUE, "")) })
 			}
 			kit.If(k == mdb.LIST, func() { list = append(list, kit.Dict(mdb.NAME, mdb.LIST, mdb.TYPE, "button", mdb.ACTION, ice.AUTO)) })
-			h := func(m *ice.Message, arg ...string) { m.Copy(s.Action(m.Spawn(Index).Spawn(m.Target()), s, k, arg...)) }
 			if k == mdb.LIST {
-				cmd.Hand, cmd.List = h, list
+				cmd.Hand, cmd.List = s.Handler(v), list
 			} else {
-				cmd.Actions[k], cmd.Meta[k] = &ice.Action{Hand: h}, list
+				cmd.Actions[k], cmd.Meta[k] = &ice.Action{Hand: s.Handler(v)}, list
 			}
 		}
 	})

base/yac/stmt.go

@@ -21,6 +21,7 @@ const (
 	DEFAULT  = "default"
 	FUNC     = "func"
 	INIT     = "init"
+	MAIN     = "main"
 	CALL     = "call"
 	DEFER    = "defer"
 	RETURN   = "return"
@@ -48,26 +49,23 @@ func init() {
 			} else {
 				f.status, f.defers = STATUS_DISABLE, append(f.defers, func() { f.status = STATUS_NORMAL })
 			}
-			s.reads(m, func(k string) bool {
+			if s.next(m) == IF {
-				if k == IF {
+				res := s.expr(m)
-					res := s.expr(m)
+				kit.If(s.token() == SPLIT, func() { res = s.expr(m) })
-					kit.If(s.token() == SPLIT, func() { res = s.expr(m) })
+				kit.If(res == ice.FALSE, func() { f.status = STATUS_DISABLE })
-					kit.If(res == ice.FALSE, func() { f.status = STATUS_DISABLE })
+			}
-				}
-				return true
-			})
 		}},
 		FOR: {Name: "for a = 1; a < 10; a++ {", Hand: func(m *ice.Message, arg ...string) {
 			s, f := _parse_frame(m)
 			if strings.Contains(s.list[s.line], RANGE) {
 				pos, key, list := s.Position, []string{}, []Any{}
 				kit.If(s.last != nil && s.last.line == s.line, func() { list, _ = s.last.value["_range"].([]Any) })
-				for { // for k, v := range value {
+				for {
 					if k := s.cals0(m, FIELD, DEFS, ASSIGN); k == RANGE {
 						if obj, ok := s.cals(m).(Operater); ok {
-							if _list, ok := obj.Operate(RANGE, list).([]Any); ok {
+							if list, ok := obj.Operate(RANGE, list).([]Any); ok {
-								kit.For(key, func(i int, k string) { f.value[k] = _list[i] })
+								kit.For(key, func(i int, k string) { f.value[k] = list[i] })
-								f.value["_range"] = _list
+								f.value["_range"] = list
 								break
 							}
 						}
@@ -102,8 +100,7 @@ func init() {
 			s.Position, f.defers = list[len(list)-1], append(f.defers, func() {
 				if s.runable() {
 					kit.If(len(list) > 3, func() { s.expr(m, list[2]) })
-					s.Position = list[0]
+					s.pos(m, list[0], -1)
-					s.Position.skip--
 				}
 			})
 		}},
@@ -148,9 +145,12 @@ func init() {
 			f.status = STATUS_NORMAL
 			v := s.cals(m)
 			f.status = STATUS_DISABLE
+			if f.value["_case"] == "done" {
+				return
+			}
 			if res, ok := v.(Operater); ok {
 				if res, ok := res.Operate("==", Trans(s.value(m, "_switch"))).(Boolean); ok && res.value {
-					f.status, f.value["_case"] = 0, "done"
+					f.status, f.value["_case"] = STATUS_NORMAL, "done"
 				}
 			}
 		}},
@@ -164,53 +164,32 @@ func init() {
 		}},
 		FUNC: {Name: "func show(a, b) (c, d)", Hand: func(m *ice.Message, arg ...string) {
 			s := _parse_stack(m)
-			list, key, kind := [][]Field{[]Field{}}, "", ""
+			field, list := Field{}, []Field{}
-			push := func() {
+			if s.next(m) == OPEN {
-				kit.If(key, func() { list[len(list)-1], key, kind = append(list[len(list)-1], Field{name: key, kind: kind}), "", "" })
+				for s.next(m) != CLOSE {
+					kit.If(field.name == "", func() { field.name = s.token() }, func() { field.types = s.token() })
+				}
+				s.next(m)
+				list = append(list, field)
 			}
-			s.reads(m, func(k string) bool {
+			name := s.token()
-				switch k {
+			list = append(list, Field{name: name})
-				case OPEN:
+			s.rest[s.skip] = FUNC
-					defer kit.If(key != "" || len(list) > 1, func() { list = append(list, []Field{}) })
+			v := s.funcs(m, name)
-				case FIELD, CLOSE:
+			if v.obj = list; field.types != nil {
-				case BEGIN:
+				if t, ok := s.value(m, kit.Format(field.types)).(Struct); ok {
-					return true
+					m.Debug("value %s set %s.%s %s", Format(s), field.types, name, Format(v))
-				default:
+					t.index[name] = v
-					kit.If(key, func() { kind = k }, func() { key = k })
-					return false
 				}
-				push()
+			} else if name != INIT {
-				return false
+				s.value(m, name, v)
-			})
-			m.Debug("what %#v", list)
-			kit.If(len(list) < 2, func() { list = append(list, []Field{}) })
-			kit.If(len(list) < 3, func() { list = append(list, []Field{}) })
-			name, fun := list[0][len(list[0])-1].name, Function{obj: list[0], arg: list[1], res: list[2], Position: s.Position}
-			if len(list[0]) > 1 {
-				if st, ok := list[0][0].kind.(Struct); ok {
-					st.method = append(st.method, fun)
-					st.index[name] = fun
-				}
-				if st, ok := list[0][0].kind.(string); ok {
-					if st, ok := s.value(m, st).(Struct); ok {
-						st.method = append(st.method, fun)
-						st.index[name] = fun
-					}
-				}
-
-			} else {
-				kit.If(name != INIT, func() { s.value(m, name, fun) })
-			}
-			if f := s.pushf(m, ""); name == INIT {
-				f.key = CALL
-			} else {
-				f.status = STATUS_DISABLE
 			}
 		}},
 		DEFER: {Name: "defer func() {} ()", Hand: func(m *ice.Message, arg ...string) {
 			s := _parse_stack(m)
-			k := s.next(m)
+			obj, k := Any(nil), ""
-			kit.If(k == FUNC, func() { k = s.funcs(m) })
+			obj, k = s, s.next(m)
+			kit.If(k == FUNC, func() { obj, k = s.funcs(m, ""), "" })
 			s.skip++
 			args := _parse_res(m, s.cals(m))
 			if !s.runable() {
@@ -218,7 +197,7 @@ func init() {
 			}
 			s.stack(func(f *Frame, i int) bool {
 				if f.key == CALL {
-					f.defers = append(f.defers, func() { s.calls(m, s, k, nil, args...) })
+					f.defers = append(f.defers, func() { s.calls(m, obj, k, nil, args...) })
 					return true
 				}
 				return false
@@ -258,16 +237,44 @@ func init() {
 			m.EchoLine("").EchoLine("stack: %s", arg[0])
 			_parse_stack(m).stack(func(f *Frame, i int) bool {
 				m.EchoLine("frame: %s %v:%v:%v", f.key, f.name, f.line, f.skip)
-				kit.For(f.value, func(k string, v Any) { m.EchoLine("  %s: %#v", k, v) })
+				show := func(p string) string {
+					ls := nfs.SplitPath(m, p)
+					return ice.Render(m, ice.RENDER_ANCHOR, p, m.MergePodCmd("", "web.code.vimer", nfs.PATH, ls[0], nfs.FILE, ls[1], nfs.LINE, ls[2]))
+				}
+				kit.For(f.value, func(k string, v Any) {
+					switch v := v.(type) {
+					case func(*ice.Message, string, ...Any) Any:
+						m.EchoLine("  %s: %v", k, show(kit.FileLine(v, 100)))
+					case Message:
+						m.EchoLine("  %s: %v", k, show(kit.FileLine(v.Call, 100)))
+					case Function:
+						m.EchoLine("  %s: %v", k, show(v.Position.name+":"+kit.Format(v.Position.line+1)))
+					case Struct:
+						m.EchoLine("  %s: struct", k)
+						kit.For(v.index, func(k string, v Any) {
+							switch v := v.(type) {
+							case Function:
+								m.EchoLine("  	%s: %v", k, show(v.Position.name+":"+kit.Format(v.Position.line+1)))
+							case Field:
+								m.EchoLine("  	%s: %v", k, v.Format())
+							}
+						})
+					case string:
+						m.EchoLine("  %s: %v", k, v)
+					default:
+						m.EchoLine("  %s: %v", k, Format(v))
+					}
+				})
 				return false
 			})
 			m.EchoLine("stmt: %s", arg[0])
-			for key, cmd := range m.Target().Commands {
+			kit.For(kit.SortedKey(m.Target().Commands), func(key string) {
-				if strings.HasPrefix(key, "_") || strings.HasPrefix(key, "/") {
+				if strings.HasPrefix(key, "_") || strings.HasPrefix(key, ice.PS) {
-					continue
+					return
 				}
+				cmd := m.Target().Commands[key]
 				m.EchoLine("  %s: %#v", key, cmd.Name)
-			}
+			})
 		}},
 		PWD: {Name: "pwd", Hand: func(m *ice.Message, arg ...string) {
 			s := _parse_stack(m)

base/yac/type.go

@@ -1,42 +1,45 @@
 package yac
 
 import (
+	"strings"
+
 	ice "shylinux.com/x/icebergs"
 	kit "shylinux.com/x/toolkits"
 )
 
-const (
-	CONST = "const"
-	TYPE  = "type"
-	VAR   = "var"
-
-	STRING    = "string"
-	INT       = "int"
-	MAP       = "map"
-	SLICE     = "slice"
-	STRUCT    = "struct"
-	INTERFACE = "interface"
-)
-
 type Map struct {
-	key   Any
 	value Any
+	key   Any
 }
 type Slice struct {
 	value Any
 }
 type Interface struct {
 	index map[string]Function
+	name  string
 }
 type Struct struct {
-	index  map[string]Any
+	index map[string]Any
-	method []Function
+	name  string
-	field  []Field
 }
 type Field struct {
-	name string
+	types Any
-	kind Any
+	tags  map[string]string
+	name  string
 }
+
+func (s Field) MarshalJSON() ([]byte, error) {
+	return []byte(kit.Format("%q", s.Format())), nil
+}
+func (s Field) Format() string {
+	if len(s.tags) == 0 {
+		return kit.Format("%s", s.types)
+	}
+	res := []string{}
+	kit.For(s.tags, func(k, v string) { res = append(res, kit.Format("%s:\"%s\"", k, v)) })
+	return kit.Format("%s `%s`", s.types, strings.Join(res, ice.SP))
+}
+
 type Object struct {
 	value Operater
 	index Struct
@@ -46,6 +49,33 @@ func (s Object) Operate(op string, v Any) Any {
 	switch op {
 	case "&", "*":
 		return s
+	case INSTANCEOF:
+		if t, ok := v.(Struct); ok {
+			return Value{list: []Any{s, s.index.name == t.name}}
+		}
+		return Value{list: []Any{s, false}}
+	case IMPLEMENTS:
+		if t, ok := v.(Interface); ok {
+			for k, v := range t.index {
+				if _v, ok := s.index.index[k].(Function); ok {
+					for i, field := range v.arg {
+						if i < len(_v.arg) && _v.arg[i].types == field.types {
+							continue
+						}
+						return Value{list: []Any{s, false}}
+					}
+					for i, field := range v.res {
+						if i < len(_v.res) && _v.res[i].types == field.types {
+							continue
+						}
+						return Value{list: []Any{s, false}}
+					}
+				} else {
+					return Value{list: []Any{s, false}}
+				}
+			}
+		}
+		return Value{list: []Any{s, true}}
 	case SUBS:
 		switch v := s.index.index[kit.Format(v)].(type) {
 		case Function:
@@ -59,6 +89,22 @@ func (s Object) Operate(op string, v Any) Any {
 	return nil
 }
 
+const (
+	MAP       = "map"
+	SLICE     = "slice"
+	STRUCT    = "struct"
+	INTERFACE = "interface"
+	STRING    = "string"
+	INT       = "int"
+
+	INSTANCEOF = "instanceof"
+	IMPLEMENTS = "implements"
+
+	CONST = "const"
+	TYPE  = "type"
+	VAR   = "var"
+)
+
 func init() {
 	Index.MergeCommands(ice.Commands{
 		CONST: {Name: "const a = 1", Hand: func(m *ice.Message, arg ...string) {
@@ -80,7 +126,16 @@ func init() {
 				s.next(m)
 				fallthrough
 			default:
-				s.value(m, name, s.types(m))
+				switch t := s.types(m).(type) {
+				case Interface:
+					t.name = name
+					s.value(m, name, t)
+				case Struct:
+					t.name = name
+					s.value(m, name, t)
+				default:
+					s.value(m, name, t)
+				}
 			}
 		}},
 		VAR: {Name: "var a = 1", Hand: func(m *ice.Message, arg ...string) {

base/yac/value.go

@@ -7,33 +7,35 @@ import (
 	"time"
 
 	ice "shylinux.com/x/icebergs"
+	"shylinux.com/x/icebergs/base/mdb"
 	"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 Dict struct{ value map[string]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 Dict) 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 Function) MarshalJSON() ([]byte, error) {
+	return []byte(kit.Format("%q", Format(s.Position))), nil
+}
 
-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 map[string]Any:
+		return Dict{v}
 	case string:
 		return String{v}
 	case int:
@@ -46,16 +48,16 @@ func wrap(v Any) Any {
 }
 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 List:
+		return v.value
+	case Dict:
+		return v.value
 	case String:
 		return v.value
 	case Number:
@@ -66,30 +68,6 @@ func Trans(v Any) Any {
 		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:
@@ -123,6 +101,30 @@ func (s List) Operate(op string, v Any) Any {
 	}
 	return nil
 }
+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 String) Operate(op string, v Any) Any {
 	switch a, b := s.value, kit.Format(v); op {
 	case "+":
@@ -191,16 +193,16 @@ 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 "Dict":
+			return kit.Dict(arg...)
 		case "Format":
 			return kit.Format(arg[0], arg[1:]...)
 		case "Formats":
 			return kit.Formats(arg[0])
 		default:
-			m.ErrorNotImplement(key)
+			m.ErrorNotImplement(kit.Keys("kit", key))
 			return nil
 		}
 	}
@@ -209,17 +211,26 @@ func (s *Stack) load(m *ice.Message, cb func(*Frame)) *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) {
+			switch v := v.(type) {
 			case Function:
+				v.object = obj
 				if k == "List" {
 					command.Hand = stack.Handler(v)
 				} else {
-					command.Actions[k] = &ice.Action{Hand: stack.Handler(v)}
+					command.Actions[kit.LowerCapital(k)] = &ice.Action{Hand: stack.Handler(v)}
+				}
+			}
+		}
+		for k, v := range obj.index.index {
+			switch v := v.(type) {
+			case Field:
+				if k == "list" {
+					command.Name = v.tags[mdb.NAME]
+				} else {
+					command.Actions[k].Name = v.tags[mdb.NAME]
 				}
-			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
@@ -232,7 +243,9 @@ func (s *Stack) load(m *ice.Message, cb func(*Frame)) *Stack {
 				last.Merge(last)
 			})
 		}
-		m.Debug("what %#v", command)
+		link := ice.Render(m, ice.RENDER_ANCHOR, kit.Format(arg[0]), m.MergePodCmd("", kit.Format(arg[0])))
+		s.frame[0].value["_index"] = kit.Format(arg[0])
+		s.frame[0].value["_link"] = link
 		return nil
 	}
 	f.value["ice.MergeActions"] = func(m *ice.Message, key string, arg ...Any) Any {
@@ -247,9 +260,7 @@ func (s *Stack) load(m *ice.Message, cb func(*Frame)) *Stack {
 		return res
 	}
 	for k, v := range ice.Info.Stack {
-		if strings.HasPrefix(k, "web.code.") {
+		kit.If(strings.HasPrefix(k, "web.code."), func() { k = strings.TrimPrefix(k, "web.") })
-			k = strings.TrimPrefix(k, "web.")
-		}
 		f.value[k] = v
 	}
 	f.value["m"] = Message{m}
@@ -272,6 +283,11 @@ func (m Message) Call(cmd string, arg ...Any) Any {
 		m.Push(str(arg[0]), arg[1], arg[2:]...)
 	case "Echo":
 		m.Echo(str(arg[0]), arg[1:]...)
+	case "Table":
+		s := _parse_stack(m.Message)
+		m.Table(func(val ice.Maps) { s.calls(m.Message, arg[0], "", nil, Dict{kit.Dict(val)}) })
+	case "Sleep":
+		m.Sleep(str(arg[0]))
 	case "Action":
 		m.Action(arg...)
 	case "Display":
@@ -293,11 +309,6 @@ func (m Message) Call(cmd string, arg ...Any) Any {
 			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)
 	}
@@ -335,10 +346,11 @@ func TransCommands(m *ice.Message, arg ...Any) ice.Commands {
 			case "Actions":
 				s.Actions = TransActions(m, v)
 			case "Hand":
-				s.Hand = func(m *ice.Message, arg ...string) {
+				switch v := v.(type) {
-					msg := m.Spawn(Index).Spawn(m.Target())
+				case Function:
-					stack.Action(msg, v, nil, arg...)
+					s.Hand = stack.Handler(v)
-					m.Copy(msg)
+				case ice.Handler:
+					s.Hand = v
 				}
 			}
 		})
@@ -361,13 +373,67 @@ func TransActions(m *ice.Message, arg ...Any) ice.Actions {
 		case "Help":
 			s.Help = kit.Format(Trans(v))
 		case "Hand":
-			s.Hand = func(m *ice.Message, arg ...string) {
+			switch v := v.(type) {
-				msg := m.Spawn(Index).Spawn(m.Target())
+			case Function:
-				stack.Action(msg, v, nil, arg...)
+				s.Hand = stack.Handler(v)
-				m.Copy(msg)
+			case ice.Handler:
+				s.Hand = v
 			}
 		}
 		actions[k] = s
 	})
 	return actions
 }
+
+func Format(arg ...Any) string {
+	res := []string{}
+	for _, v := range arg {
+		switch v := v.(type) {
+		case func(*ice.Message, string, ...Any) Any:
+			res = append(res, kit.FileLine(v, 100))
+		case Message:
+			res = append(res, kit.FileLine(v.Call, 100))
+		case Function:
+			res = append(res, kit.Format("%s %s%s%s", Format(v.obj[:len(v.obj)-1]), v.obj[len(v.obj)-1].name, Format(v.arg), Format(v.res)), Format(v.Position))
+		case *Stack:
+			res = append(res, kit.Format("%d:%s", len(v.frame)-1, kit.Select(v.peekf().key, v.peekf().name)))
+		case Position:
+			if v.Buffer == nil {
+				continue
+			} else if v.skip == -1 {
+				res = append(res, kit.Format("%s:%d", v.name, v.line+1))
+			} else {
+				res = append(res, kit.Format("%s:%d:%d", v.name, v.line+1, v.skip))
+			}
+		case Map:
+			res = append(res, kit.Format("map[%s]%s", v.key, v.value))
+		case Slice:
+			res = append(res, kit.Format("[]%s", v.value))
+		case Interface:
+			res = append(res, kit.Format("interface%s", v.name))
+		case Struct:
+			res = append(res, kit.Format("struct%s", Format(v.index)))
+		case Object:
+			res = append(res, kit.Format("%s:%s", v.index.name, Format(v.value)))
+		case []Field:
+			for i, field := range v {
+				res = append(res, kit.Select("", OPEN, i == 0)+field.name, kit.Format(field.types)+kit.Select(FIELD, CLOSE, i == len(v)-1))
+			}
+		case List:
+			res = append(res, kit.Format(v.value))
+		case Dict:
+			res = append(res, kit.Format(v.value))
+		case String:
+			res = append(res, kit.Format("%q", v.value))
+		case Number:
+			res = append(res, kit.Format("%s", v.value))
+		case Boolean:
+			res = append(res, kit.Format("%t", v.value))
+		case string:
+			res = append(res, kit.Format("%q", v))
+		default:
+			res = append(res, kit.Format(v))
+		}
+	}
+	return strings.Join(res, " ")
+}

core/code/shy.go

@@ -30,7 +30,11 @@ func init() {
 				ctx.ProcessCommand(m, yac.STACK, kit.Simple(arg[1]))
 			}},
 			mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
-				ctx.ProcessCommand(m, yac.STACK, kit.Simple(arg[1]))
+				if msg := m.Cmd(yac.STACK, arg[1]); msg.Option("__index") != "" {
+					ctx.ProcessCommand(m, msg.Option("__index"), kit.Simple())
+				} else {
+					ctx.ProcessCommand(m, yac.STACK, kit.Simple(arg[1]))
+				}
 			}},
 			TEMPLATE: {Hand: func(m *ice.Message, arg ...string) {
 				m.Echo(nfs.Template(m, "demo.shy"), path.Base(path.Dir(path.Join(arg[2], arg[1]))))

render.go

@@ -179,6 +179,16 @@ func (m *Message) PushDownload(key string, arg ...string) *Message {
 	return m
 }
 
+func (m *Message) EchoFields(cmd string) *Message {
+	return m.Echo(`<fieldset class="story" data-index="%s">
+<legend></legend>
+<form class="option"></form>
+<div class="action"></div>
+<div class="output"></div>
+<div class="status"></div>
+</fieldset>
+`, cmd)
+}
 func (m *Message) EchoButton(arg ...Any) *Message    { return m.Echo(Render(m, RENDER_BUTTON, arg...)) }
 func (m *Message) EchoAnchor(arg ...string) *Message { return m.Echo(Render(m, RENDER_ANCHOR, arg)) }
 func (m *Message) EchoQRCode(src string) *Message    { return m.Echo(Render(m, RENDER_QRCODE, src)) }