func SliceTypeParserExt(env Env) p.Parser {
return func(st p.ParseState) (interface{}, error) {
t, err := p.Bind_(p.String("[]"), ExtTypeParser(env))(st)
if err != nil {
return nil, err
}
return reflect.SliceOf(t.(Type).Type), nil
}
}
func ExtTypeParser(env Env) p.Parser {
return func(st p.ParseState) (interface{}, error) {
_, err := p.String("::")(st)
if err != nil {
return nil, err
}
buildin := p.Choice(
p.Try(p.Bind_(typeName("bool"), p.Return(BOOL))),
p.Try(p.Bind_(typeName("float"), p.Return(FLOAT))),
p.Try(p.Bind_(typeName("int"), p.Return(INT))),
p.Try(p.Bind_(typeName("string"), p.Return(STRING))),
p.Try(p.Bind_(typeName("time"), p.Return(TIME))),
p.Try(p.Bind_(typeName("duration"), p.Return(DURATION))),
p.Try(p.Bind_(typeName("any"), p.Return(ANY))),
p.Try(p.Bind_(typeName("atom"), p.Return(ATOM))),
p.Try(p.Bind_(p.String("list"), p.Return(LIST))),
p.Try(p.Bind_(typeName("quote"), p.Return(QUOTE))),
p.Try(p.Bind_(p.String("dict"), p.Return(DICT))),
p.Try(MapTypeParserExt(env)),
)
ext := func(st p.ParseState) (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
} else {
return nil, st.Trap("var %v is't a type. It is %v", n, reflect.TypeOf(t))
}
}
t, err := p.Either(buildin, ext)(st)
if err != nil {
return nil, err
}
_, err = p.Try(p.Rune('?'))(st)
option := err == nil
return Type{t.(reflect.Type), option}, nil
}
}
func MapTypeParser(st p.ParseState) (interface{}, error) {
key, err := p.Between(p.String("map["), p.Rune(']'), 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
}
func typeName(word string) p.Parser {
return p.Bind(p.String(word), stopWord)
}
func TypeParser(st p.ParseState) (interface{}, error) {
t, err := p.Bind_(p.String("::"),
p.Choice(
p.Try(p.Bind_(p.String("bool"), p.Return(BOOL))),
p.Try(p.Bind_(p.String("float"), p.Return(FLOAT))),
p.Try(p.Bind_(p.String("int"), p.Return(INT))),
p.Try(p.Bind_(p.String("string"), p.Return(STRING))),
p.Try(p.Bind_(p.String("time"), p.Return(TIME))),
p.Try(p.Bind_(p.String("duration"), p.Return(DURATION))),
p.Try(p.Bind_(p.String("any"), p.Return(ANY))),
p.Try(p.Bind_(p.String("atom"), p.Return(ATOM))),
p.Try(p.Bind_(p.String("list"), p.Return(LIST))),
p.Try(p.Bind_(p.String("quote"), p.Return(QUOTE))),
p.Try(p.Bind_(p.String("dict"), p.Return(DICT))),
MapTypeParser,
))(st)
if err != nil {
return nil, err
}
_, err = p.Try(p.Rune('?'))(st)
option := err == nil
return Type{t.(reflect.Type), option}, nil
}
"str": func(env Env, args ...interface{}) (Lisp, error) {
if len(args) != 1 {
return nil, ParsexSignErrorf("Str Arg Error:except args has 1 arg.")
}
param, err := Eval(env, args[0])
if err != nil {
return nil, err
}
var (
data string
ok bool
)
if data, ok = param.(string); !ok {
return nil, ParsexSignErrorf("Str Arg Error:except args has 1 string arg.")
}
return ParsecBox(p.String(data)), nil
},
"rune": func(env Env, args ...interface{}) (Lisp, error) {
if len(args) != 1 {
return nil, ParsexSignErrorf("Rune Arg Error:except args has 1 arg.")
}
param, err := Eval(env, args[0])
if err != nil {
return nil, err
}
var (
data Rune
ok bool
)
if data, ok = param.(Rune); !ok {
return nil, ParsexSignErrorf("One Arg Error:except args has 1 rune arg but %v.", reflect.TypeOf(param))
package gisp
import (
"fmt"
p "github.com/Dwarfartisan/goparsec"
)
// Bool 是内置的 bool 类型的封装
type Bool bool
// BoolParser 解析 bool
var BoolParser = p.Bind(p.Choice(p.String("true"), p.String("false")), func(input interface{}) p.Parser {
return func(st p.ParseState) (interface{}, error) {
switch input.(string) {
case "true":
return Bool(true), nil
case "false":
return Bool(false), nil
default:
return nil, fmt.Errorf("Unexcept bool token %v", input)
}
}
})
// NilParser 解析 nil
var NilParser = p.Bind_(p.String("nil"), p.Return(nil))
// Nil 类型定义空值行为
type Nil struct {
}