// ListParser 实现数组解析器 func ListParser() p.P { return func(st p.State) (interface{}, error) { left := p.Chr('[').Then(Skip) right := Skip.Then(p.Chr(']')) empty := p.Between(left, right, Skip) // list, err := p.Between(left, right, p.UnionAll(listBodyParser))(st) list, err := p.Between(left, right, listBodyParser)(st) if err != nil { _, e := empty(st) if e != nil { return nil, err } return List{}, nil } switch l := list.(type) { case List: return L(l), nil case []interface{}: return list.([]interface{}), nil default: return nil, fmt.Errorf("List Parser Error: %v type is unexpected: %v", list, reflect.TypeOf(list)) } } }
// ObjectParser 实现数组解析器 func ObjectParser() p.P { return func(st p.State) (interface{}, error) { left := p.Chr('{').Then(Skip) right := Skip.Then(p.Chr('}')) empty := p.Between(left, right, Skip) object, err := p.Between(left, right, objectBodyParser)(st) if err != nil { _, e := empty(st) if e != nil { return nil, err } return Object{}, nil } switch o := object.(type) { case Object: return O(o), nil case map[string]interface{}: return object.(map[string]interface{}), nil default: return nil, fmt.Errorf("Object Parser Error: %v type is unexpected: %v", object, reflect.TypeOf(object)) } } }
func TestParsecRune(t *testing.T) { g := NewGispWith( map[string]Toolbox{ "axiom": Axiom, "props": Propositions, "time": Time}, map[string]Toolbox{"time": Time, "p": Parsec}) //data := "Here is a Rune : 'a' and a is't a rune. It is a word in sentence." data := "'a' and a is't a rune. It is a word in sentence." state := NewStringState(data) pre, err := p.Between(p.Chr('\''), p.Chr('\''), p.AsRune)(state) if err != nil { t.Fatalf("expect found rune expr from \"%v\" but error:%v", data, err) } src := ` (let ((st (p.state "` + data + `"))) ((p.between (p.rune '\'') (p.rune '\'') p.one) st)) ` gre, err := g.Parse(src) if err != nil { t.Fatalf("expect \"%v\" pass gisp '<rune>' but error:%v", src, err) } t.Logf("from gisp: %v", gre) t.Logf("from parsec: %v", pre) if !reflect.DeepEqual(pre, gre) { t.Fatalf("expect got \"%v\" from gisp equal \"%v\" from parsec", gre, pre) } }
// MapTypeParser 定义了序列类型解析逻辑 func MapTypeParser(st p.State) (interface{}, error) { key, err := p.Between(p.Str("map["), p.Chr(']'), TypeParser)(st) if err != nil { return nil, err } value, err := TypeParser(st) if err != nil { return nil, err } return reflect.MapOf(key.(Type).Type, value.(Type).Type), nil }
// MapTypeParserExt 定义了带环境的映射类型解析逻辑 func MapTypeParserExt(env Env) p.P { return func(st p.State) (interface{}, error) { key, err := p.Between(p.Str("map["), p.Chr(']'), ExtTypeParser(env))(st) if err != nil { return nil, err } value, err := ExtTypeParser(env)(st) if err != nil { return nil, err } return reflect.MapOf(key.(Type).Type, value.(Type).Type), nil } }
// ListParserExt 实现带扩展的列表解析器 func ListParserExt(env Env) p.P { left := p.Chr('(').Then(Skip) right := Skip.Then(p.Chr(')')) empty := left.Then(right) return func(st p.State) (interface{}, error) { list, err := p.Try(p.Between(left, right, bodyParserExt(env)))(st) if err == nil { switch l := list.(type) { case List: return L(l), nil case []interface{}: return List(l), nil default: return nil, fmt.Errorf("List Parser(ext) Error: %v type is unexpected: %v", list, reflect.TypeOf(list)) } } else { _, e := empty(st) if e == nil { return List{}, nil } return nil, err } } }
return '\t' default: panic(st.Trap("Unknown escape sequence \\%c", r)) } }) // RuneParser 实现 rune 的解析 var RuneParser = p.Do(func(state p.State) interface{} { p.Chr('\'').Exec(state) c := p.Choice(p.Try(EscapeCharr), p.NChr('\'')).Exec(state) p.Chr('\'').Exec(state) return Rune(c.(rune)) }) // StringParser 实现字符串解析 var StringParser = p.Between(p.Chr('"'), p.Chr('"'), p.Many(p.Choice(p.Try(EscapeChars), p.NChr('"')))).Bind(p.ReturnString) func bodyParser(st p.State) (interface{}, error) { value, err := p.SepBy(ValueParser(), Skip)(st) return value, err } func bodyParserExt(env Env) p.P { return p.Many(ValueParserExt(env).Over(Skip)) } // ListParser 实现列表解析器 func ListParser() p.P { return func(st p.State) (interface{}, error) { left := p.Chr('(').Then(Skip) right := Skip.Then(p.Chr(')'))
return ParsecBox(p.OneOf(params...)), nil }, "noneof": func(env Env, args ...interface{}) (Lisp, error) { params, err := Evals(env, args...) if err != nil { return nil, err } return ParsecBox(p.NoneOf(params)), nil }, "between": func(env Env, args ...interface{}) (Lisp, error) { ptype := reflect.TypeOf((*Parsecer)(nil)).Elem() params, err := GetArgs(env, p.UnionAll(TypeAs(ptype), TypeAs(ptype), TypeAs(ptype), p.EOF), args) if err != nil { return nil, err } return ParsecBox(p.Between(params[0].(Parsecer).Parser, params[1].(Parsecer).Parser, params[2].(Parsecer).Parser)), nil }, "bind": func(env Env, args ...interface{}) (Lisp, error) { if len(args) != 2 { return nil, fmt.Errorf("Bind Args Error:expect 2 args.") } prs, err := Eval(env, args[0]) if err != nil { return nil, err } var parser Parsecer var ok bool if parser, ok = prs.(Parsecer); !ok { return nil, fmt.Errorf("Bind Args Error:expect first arg is a Parsecer.") } f, err := Eval(env, args[1])
// BracketParserExt 在带有 Ext 的环境下解析中括号表达式 func BracketParserExt(env Env) p.P { return p.Between(p.Chr('['), p.Chr(']'), p.SepBy1(ValueParserExt(env), p.Chr(':')), ) }