// ExtTypeParser 定义了带环境的类型解释器
func ExtTypeParser(env Env) p.P {
return func(st p.State) (interface{}, error) {
_, err := p.Str("::")(st)
if err != nil {
return nil, err
}
builtin := p.Choice(
p.Try(typeName("bool").Then(p.Return(BOOL))),
p.Try(typeName("float").Then(p.Return(FLOAT))),
p.Try(typeName("int").Then(p.Return(INT))),
p.Try(typeName("string").Then(p.Return(STRING))),
p.Try(typeName("time").Then(p.Return(TIME))),
p.Try(typeName("duration").Then(p.Return(DURATION))),
p.Try(typeName("any").Then(p.Return(ANY))),
p.Try(typeName("atom").Then(p.Return(ATOM))),
p.Try(p.Str("list").Then(p.Return(LIST))),
p.Try(typeName("quote").Then(p.Return(QUOTE))),
p.Try(p.Str("dict").Then(p.Return(DICT))),
p.Try(MapTypeParserExt(env)),
)
ext := func(st p.State) (interface{}, error) {
n, err := anyType(st)
if err != nil {
return nil, err
}
t, ok := env.Lookup(n.(string))
if !ok {
return nil, st.Trap("type %v not found", n)
}
if typ, ok := t.(reflect.Type); ok {
return typ, nil
}
return nil, st.Trap("var %v is't a type. It is %v", n, reflect.TypeOf(t))
}
t, err := p.Choice(builtin, ext)(st)
if err != nil {
return nil, err
}
_, err = p.Try(p.Chr('?'))(st)
option := err == nil
return Type{t.(reflect.Type), option}, nil
}
}
// TypeParser 定义了一个基本的类型解释器
func TypeParser(st p.State) (interface{}, error) {
t, err := p.Str("::").Then(
p.Choice(
p.Try(p.Str("bool").Then(p.Return(BOOL))),
p.Try(p.Str("float").Then(p.Return(FLOAT))),
p.Try(p.Str("int").Then(p.Return(INT))),
p.Try(p.Str("string").Then(p.Return(STRING))),
p.Try(p.Str("time").Then(p.Return(TIME))),
p.Try(p.Str("duration").Then(p.Return(DURATION))),
p.Try(p.Str("any").Then(p.Return(ANY))),
p.Try(p.Str("atom").Then(p.Return(ATOM))),
p.Try(p.Str("list").Then(p.Return(LIST))),
p.Try(p.Str("quote").Then(p.Return(QUOTE))),
p.Try(p.Str("dict").Then(p.Return(DICT))),
MapTypeParser,
))(st)
if err != nil {
return nil, err
}
_, err = p.Try(p.Chr('?'))(st)
option := err == nil
return Type{t.(reflect.Type), option}, nil
}
func stopWord(x interface{}) p.P {
return p.P(stop).Then(p.Return(x))
}
parsers[idx] = parser.Parser
}
return nil, fmt.Errorf("Choice Args Error:expect parsec parsers but %v is %v",
prs, reflect.TypeOf(prs))
}
return ParsecBox(p.Choice(parsers...)), nil
},
"return": func(env Env, args ...interface{}) (Lisp, error) {
if len(args) != 1 {
return nil, fmt.Errorf("Parsex Parser Return Error: only accept one parsec parser as arg but %v", args)
}
param, err := Eval(env, args[0])
if err != nil {
return nil, err
}
return ParsecBox(p.Return(param)), nil
},
"option": func(env Env, args ...interface{}) (Lisp, error) {
if len(args) != 2 {
return nil, fmt.Errorf("Parsex Parser Option Error: only accept two parsex parser as arg but %v", args)
}
data, err := Eval(env, args[0])
if err != nil {
return nil, err
}
param, err := Eval(env, args[1])
if err != nil {
return nil, err
}
switch parser := param.(type) {
case Parsecer:
return func(st p.State) (interface{}, error) {
switch input.(string) {
case "true":
return Bool(true), nil
case "false":
return Bool(false), nil
default:
return nil, fmt.Errorf("Unexpect bool token %v", input)
}
}
})
// var BoolParser = p.Do(func(st p.State) interface{} {
// f := p.Try(p.Bool).Exec(st)
// switch f.(string) {
// case "true":
// return Bool(true), nil
// case "false":
// return Bool(false), nil
// default:
// return nil, fmt.Errorf("Unexpect bool token %v", input)
// }
// })
// NullParser 解析 null
var NullParser = p.Str("null").Then(p.Return(nil))
// // Null 类型定义空值行为
// type Null struct {
// }
)
// Bool 是内置的 bool 类型的封装
type Bool bool
// BoolParser 解析 bool
var BoolParser = p.Choice(p.Try(p.Str("true")), p.Str("false")).Bind(func(input interface{}) p.P {
return func(st p.State) (interface{}, error) {
switch input.(string) {
case "true":
return Bool(true), nil
case "false":
return Bool(false), nil
default:
return nil, fmt.Errorf("Unexpect bool token %v", input)
}
}
})
// NilParser 解析 nil
var NilParser = p.Str("nil").Then(p.Return(nil))
// Nil 类型定义空值行为
type Nil struct {
}
// Eval 方法实现 Lisp 值的 Eval 。 Nil 的 Eval 总是返回空值
func (n Nil) Eval(env Env) (interface{}, error) {
return nil, nil
}
func xEOF(x interface{}) p.P {
return p.P(p.EOF).Then(p.Return(x))
}
// BracketSuffixParser 定义 bracket 表达式判定
func BracketSuffixParser(x interface{}) p.P {
return p.Choice(p.Try(BracketSuffix(x)), p.Return(x))
}