yac

var Index = &ctx.Context{Name: "yac", Help: "语法中心",
	Caches: map[string]*ctx.Cache{
		"nparse": &ctx.Cache{Name: "nparse", Value: "0", Help: "解析器数量"},
	},
	Configs: map[string]*ctx.Config{
		"debug": &ctx.Config{Name: "debug", Value: "false", Help: "词法集合的最大数量"},
		"ncell": &ctx.Config{Name: "词法上限", Value: "128", Help: "词法集合的最大数量"},
		"nlang": &ctx.Config{Name: "语法上限", Value: "32", Help: "语法集合的最大数量"},
		"label": &ctx.Config{Name: "嵌套标记", Value: "####################", Help: "嵌套层级日志的标记"},
		"yac_name": &ctx.Config{Name: "yac_name", Value: "parse", Help: "模块名", Hand: func(m *ctx.Message, x *ctx.Config, arg ...string) string {
			if len(arg) > 0 {
				return arg[0]
			}
			return fmt.Sprintf("%s%d", x.Value, m.Capi("nparse", 1))

		}},
		"yac_help": &ctx.Config{Name: "yac_help", Value: "解析模块", Help: "模块帮助"},
	},
	Commands: map[string]*ctx.Command{
		"init": &ctx.Command{Name: "init [ncell [nlang]]", Help: "初始化语法矩阵", Hand: func(m *ctx.Message, c *ctx.Context, key string, arg ...string) {
			if _, ok := m.Target().Server.(*YAC); m.Assert(ok) {
				s := new(YAC)
				s.Context = m.Target()
				m.Target().Server = s
				m.Target().Begin(m, arg...)
			}

		}},
		"info": &ctx.Command{Name: "info", Help: "查看语法矩阵", Hand: func(m *ctx.Message, c *ctx.Context, key string, arg ...string) {
			if yac, ok := m.Target().Server.(*YAC); m.Assert(ok) {
				if len(arg) == 0 {
					for i, v := range yac.seed {
						m.Echo("seed: %d %v\n", i, v)
					}
					for i, v := range yac.page {
						m.Echo("page: %s %d\n", i, v)
					}
					for i, v := range yac.hash {
						m.Echo("hash: %s %d\n", i, v)
					}
					for i, v := range yac.state {
						m.Echo("node: %v %v\n", i, v)
					}
					for i, v := range yac.mat {
						for k, v := range v {
							if v != nil {
								m.Echo("node: %s(%d,%d): %v\n", yac.name(i), i, k, v)
							}
						}
					}
					return
				}

				line := yac.mat[yac.page[arg[0]]]
				if i, e := strconv.Atoi(arg[0]); e == nil {
					line = yac.mat[i]
				}

				for i := 0; i < len(line); i++ {
					if v, ok := line[byte(i)]; ok && v != nil {
						m.Echo("(%s, %d): %v\n", arg[0], i, v)
					}
				}
			}

		}},
		"train": &ctx.Command{Name: "train page hash word...", Help: "添加语法规则, page: 语法集合, hash: 语句类型, word: 语法模板", Hand: func(m *ctx.Message, c *ctx.Context, key string, arg ...string) {
			if yac, ok := m.Target().Server.(*YAC); m.Assert(ok) {
				page, ok := yac.page[arg[0]]
				if !ok {
					page = m.Capi("npage", 1)
					yac.page[arg[0]] = page
					yac.word[page] = arg[0]

					m.Assert(page < m.Capi("nlang"), "语法集合过多")
					yac.mat[page] = map[byte]*State{}
					for i := 0; i < yac.Capi("nlang"); i++ {
						yac.mat[page][byte(i)] = nil
					}
				}

				hash, ok := yac.hash[arg[1]]
				if !ok {
					hash = m.Capi("nhash", 1)
					yac.hash[arg[1]] = hash
					yac.hand[hash] = arg[1]
				}

				yac.train(m, page, hash, arg[2:])
				yac.seed = append(yac.seed, &Seed{page, hash, arg[2:]})
				yac.Cap("stream", fmt.Sprintf("%d,%s,%s", yac.Capi("nseed", 1), yac.Cap("npage"), yac.Cap("nhash")))
			}

		}},
		"parse": &ctx.Command{
			Name: "parse filename [yac_name [help]] [line line] [void void]",
			Help: "解析文件, filename: yac_name:模块名, yac_help:模块帮助, 文件名, line: 默认语法, void: 默认空白",
			Hand: func(m *ctx.Message, c *ctx.Context, key string, arg ...string) {
				if yac, ok := m.Target().Server.(*YAC); m.Assert(ok) {
					m.Optioni("page", yac.page["line"])
					m.Optioni("void", yac.page["void"])
					m.Start(m.Confx("yac_name", arg, 1), m.Confx("yac_help", arg, 2), key, arg[0])
				}

			}},
	},
}