// 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, p.Many(p.Choice(objectBodyParser, p.NChr('}'))))(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))
}
}
}
// 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.Many(p.Choice(p.NChr(']'), listBodyParser)))(st)
fmt.Printf("list type :%v, value :%v, err: %v\n", reflect.TypeOf(list), list, err)
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))
}
}
}
// 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
}
}
// SuffixParser 定义了后缀表达式的通用判定
func SuffixParser(prefix interface{}) p.P {
suffix := p.Choice(p.Try(DotSuffix(prefix)), BracketSuffix(prefix))
return func(st p.State) (interface{}, error) {
s, err := suffix(st)
if err != nil {
return prefix, nil
}
return SuffixParser(s)(st)
}
}
// FloatParser 解析浮点数
func FloatParser(st p.State) (interface{}, error) {
return p.Do(func(st p.State) interface{} {
f := p.Choice(p.Try(p.Float), p.Try(p.Int)).Exec(st)
val, err := strconv.ParseFloat(f.(string), 64)
if err == nil {
return Float(val)
}
panic(st.Trap("%v", err))
})(st)
}
// QuoteParser 实现 Quote 语法的解析
func QuoteParser(st p.State) (interface{}, error) {
lisp, err := p.Chr('\'').Then(
p.Choice(
p.Try(p.P(AtomParser).Bind(SuffixParser)),
ListParser().Bind(SuffixParser),
))(st)
if err == nil {
return Quote{lisp}, nil
}
return nil, err
}
// ValueParser 实现简单的值解释器
func ValueParser() p.P {
return func(st p.State) (interface{}, error) {
value, err := p.Choice(p.Try(StringParser),
p.Try(FloatParser),
p.Try(ObjectParser()),
p.Try(ListParser()),
p.Try(BoolParser),
p.Try(NullParser),
)(st)
return value, err
}
}
func stop(st p.State) (interface{}, error) {
tran := st.Begin()
defer st.Rollback(tran)
r, err := p.Choice(
p.Try(p.Space),
p.Try(p.Newline),
p.Try(p.RuneOf(":.()[]{}?")),
p.Try(p.EOF),
)(st)
if err != nil {
return nil, err
}
return r, nil
}
// ValueParser 实现简单的值解释器
func ValueParser() p.P {
return func(state p.State) (interface{}, error) {
value, err := p.Choice(p.Try(StringParser),
p.Try(FloatParser),
p.Try(IntParser),
p.Try(RuneParser),
p.Try(StringParser),
p.Try(BoolParser),
p.Try(NilParser),
p.Try(p.P(AtomParser).Bind(SuffixParser)),
p.Try(p.P(ListParser()).Bind(SuffixParser)),
p.Try(DotExprParser),
QuoteParser,
)(state)
return value, err
}
}
// ValueParserExt 表示带扩展的值解释器
func ValueParserExt(env Env) p.P {
return func(st p.State) (interface{}, error) {
value, err := p.Choice(p.Try(StringParser),
p.Try(FloatParser),
p.Try(IntParser),
p.Try(RuneParser),
p.Try(StringParser),
p.Try(BoolParser),
p.Try(NilParser),
p.Try(AtomParserExt(env).Bind(SuffixParserExt(env))),
p.Try(ListParserExt(env).Bind(SuffixParserExt(env))),
p.Try(DotExprParser),
p.Try(BracketExprParserExt(env)),
QuoteParserExt(env),
)(st)
return value, err
}
}
func compare(st p.State) (interface{}, error) {
l, err := p.Choice(
p.Try(IntValue).Bind(LessThanNumber),
p.Try(NumberValue).Bind(LessThanFloat),
p.Try(StringValue).Bind(LessThanString),
p.P(TimeValue).Bind(LessThanTime),
).Bind(func(l interface{}) p.P {
return func(st p.State) (interface{}, error) {
_, err := p.EOF(st)
if err != nil {
return nil, fmt.Errorf("less args sign error: expect eof")
}
return l, nil
}
})(st)
if err == nil {
return l, nil
}
return nil, fmt.Errorf("expect two lessable values compare but error %v", err)
}
// 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 less(env Env) p.P {
return func(st p.State) (interface{}, error) {
l, err := p.Choice(
p.Try(p.P(IntValue).Bind(LessThanNumber)),
p.Try(p.P(NumberValue).Bind(LessThanFloat)),
p.Try(p.P(StringValue).Bind(LessThanString)),
p.Try(p.P(TimeValue).Bind(LessThanTime)),
p.P(ListValue).Bind(LessThanList(env)),
).Bind(func(l interface{}) p.P {
return func(st p.State) (interface{}, error) {
_, err := p.EOF(st)
if err != nil {
return nil, st.Trap("less args sign error: expect eof")
}
return l, nil
}
})(st)
if err == nil {
return l, nil
}
return nil, st.Trap("expect two lessable values compare but error %v", err)
}
}
func objectBodyParser(st p.State) (interface{}, error) {
return p.SepBy1(ValueParser(), p.Choice(Colon))(st)
}
)(st)
if err != nil {
return nil, err
}
return r, nil
}
func stopWord(x interface{}) p.P {
return p.P(stop).Then(p.Return(x))
}
func typeName(word string) p.P {
return p.Str(word).Bind(stopWord)
}
var anyType = p.Many1(p.Choice(p.Try(p.Digit), p.Letter)).Bind(stopWord).Bind(p.ReturnString)
// SliceTypeParserExt 定义了带环境的序列类型解析逻辑
func SliceTypeParserExt(env Env) p.P {
return func(st p.State) (interface{}, error) {
t, err := p.Str("[]").Then(ExtTypeParser(env))(st)
if err != nil {
return nil, err
}
return reflect.SliceOf(t.(Type).Type), nil
}
}
// MapTypeParserExt 定义了带环境的映射类型解析逻辑
func MapTypeParserExt(env Env) p.P {
return func(st p.State) (interface{}, error) {
func(args ...interface{}) Tasker {
return func(env Env) (interface{}, error) {
return MakeRecvChan(args[0].(reflect.Type), args[1].(Int)), nil
}
}},
"chan<-": SimpleBox{
SignChecker(TypeAs(reflect.TypeOf((*reflect.Type)(nil)).Elem()).
Then(TypeAs(INT)).Then(p.EOF)),
func(args ...interface{}) Tasker {
return func(env Env) (interface{}, error) {
return MakeSendChan(args[0].(reflect.Type), args[1].(Int)), nil
}
}},
"send": SimpleBox{
SignChecker(TypeAs(reflect.TypeOf((*Chan)(nil))).
Then(p.Choice(p.Try(TypeAs(ANYOPTION)), TypeAs(ANYMUST))).
Then(p.EOF)),
func(args ...interface{}) Tasker {
return func(env Env) (interface{}, error) {
ch := args[0].(*Chan)
ch.Send(args[1])
return nil, nil
}
}},
"send?": SimpleBox{
SignChecker(TypeAs(reflect.TypeOf((*Chan)(nil))).
Then(p.Choice(p.Try(TypeAs(ANYOPTION)), TypeAs(ANYMUST))).
Then(p.EOF)),
func(args ...interface{}) Tasker {
return func(env Env) (interface{}, error) {
ch := args[0].(*Chan)
// BracketSuffixParser 定义 bracket 表达式判定
func BracketSuffixParser(x interface{}) p.P {
return p.Choice(p.Try(BracketSuffix(x)), p.Return(x))
}
func ExtReverseExpr(expr func(Env) p.P) LispExpr {
return func(env Env, args ...interface{}) (Lisp, error) {
return ParsecReverseExpr(expr(env))(env, args...)
}
}
var addExpr = ParsecExpr(addx)
var subExpr = ParsecExpr(subx)
var mulExpr = ParsecExpr(mulx)
var divExpr = ParsecExpr(divx)
var lessExpr = ExtExpr(less)
var lsoExpr = ExtExpr(lessOption)
var leExpr = OrExtRExpr(equals, less)
var leoExpr = OrExtRExpr(equalsOption, lessOption)
var cmpExpr = ParsecExpr(compare)
var greatExpr = ExtReverseExpr(less)
var gtoExpr = ExtReverseExpr(lessOption)
var geExpr = OrExtRExpr(equals, less)
var geoExpr = func(env Env, args ...interface{}) (Lisp, error) {
st := p.NewBasicState(args)
ret, err := p.Choice(p.Try(NotParsec(less(env))), FalseIfHasNil)(&st)
if err != nil {
return nil, err
}
return Q(ret), nil
}
var eqsExpr = ParsecExpr(equals)
var eqsoExpr = ParsecExpr(equalsOption)
var neqsExpr = NotExpr(eqsExpr)
var neqsoExpr = ParsecExpr(neqsOption)
package pjson
import (
"fmt"
p "github.com/Dwarfartisan/goparsec2"
)
// Bool 是内置的 bool 类型
type Bool bool
// BoolParser 解析 bool
// BoolParser 解析 bool
var BoolParser = p.Choice(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)
}
}
})
// 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
// 环境做了妥协
var Axiom = Toolkit{
Meta: map[string]interface{}{
"name": "axiom",
"category": "package",
},
Content: map[string]interface{}{
"quote": LispExpr(func(env Env, args ...interface{}) (Lisp, error) {
if len(args) != 1 {
return nil, fmt.Errorf("Quote Args Error: expect only one arg but %v", args)
}
return Q(Q(args[0])), nil
}),
"var": LispExpr(func(env Env, args ...interface{}) (Lisp, error) {
st := p.NewBasicState(args)
_, err := TypeAs(ATOM).Then(p.Choice(p.Try(p.EOF), p.P(p.One).Then(p.EOF)))(&st)
if err != nil {
return nil, err
}
first := args[0].(Atom)
slot := VarSlot(first.Type)
if len(args) == 1 {
err := env.Defvar(first.Name, slot)
return Q(nil), err
}
val, err := Eval(env, args[1])
slot.Set(val)
err = env.Defvar(first.Name, slot)
return Q(val), err
}),
case Parsecer:
return ParsecBox(p.Try(parser.Parser)), nil
default:
return nil, fmt.Errorf(
"Try Arg Error:expect 1 parser arg but %v.",
reflect.TypeOf(param))
}
},
"either": func(env Env, args ...interface{}) (Lisp, error) {
ptype := reflect.TypeOf((p.P)(nil))
params, err := GetArgs(env, p.UnionAll(TypeAs(ptype), TypeAs(ptype), p.EOF), args)
if err != nil {
return nil, err
}
return ParsecBox(p.Choice(params[0].(Parsecer).Parser, params[1].(Parsecer).Parser)), nil
},
"choice": func(env Env, args ...interface{}) (Lisp, error) {
ptype := reflect.TypeOf((p.P)(nil))
params, err := GetArgs(env, p.Many(TypeAs(ptype)).Over(p.EOF), args)
if err != nil {
return nil, err
}
parsers := make([]p.P, len(params))
for idx, prs := range params {
if parser, ok := prs.(Parsecer); ok {
parsers[idx] = parser.Parser
}
return nil, fmt.Errorf("Choice Args Error:expect parsec parsers but %v is %v",
prs, reflect.TypeOf(prs))
}
return '\n'
case '\'':
return '\''
case '\\':
return '\\'
case 't':
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))
