// 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)
}
// SuffixParserExt 在后缀表达式判定中允许传入环境
func SuffixParserExt(env Env) func(interface{}) p.P {
return func(prefix interface{}) p.P {
suffix := p.Choice(p.Try(DotSuffix(prefix)), BracketSuffixExt(env)(prefix))
return func(st p.State) (interface{}, error) {
s, err := p.Try(suffix)(st)
if err != nil {
return prefix, nil
}
return SuffixParserExt(env)(s)(st)
}
}
}
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
}
// divx 实现一个左折叠的 parsec 连除解析器，精度向上适配。
func divx(st p.State) (interface{}, error) {
data, err := p.Try(p.Many(IntValue).Over(p.EOF))(st)
if err == nil {
ints := data.([]interface{})
root := ints[0].(Int)
for _, x := range ints[1:] {
root /= x.(Int)
}
return root, nil
}
data, err = p.Many(NumberValue).Over(p.EOF)(st)
if err == nil {
numbers := data.([]interface{})
root := numbers[0].(Float)
for _, x := range numbers[1:] {
root /= x.(Float)
}
return root, nil
}
if nerr, ok := err.(NotNumberError); ok {
return nil, TypeSignError{Type: Type{FLOAT, false}, Value: nerr.Value}
}
return nil, err
}
// Parse 分析JSON源码
func Parse(code string) (interface{}, error) {
st := p.BasicStateFromText(code)
var v interface{}
var e error
for {
Skip(&st)
_, err := p.Try(p.EOF)(&st)
if err == nil {
break
}
value, err := ValueParser()(&st)
if err != nil {
return nil, err
}
switch vv := value.(type) {
default:
v = vv
e = nil
}
}
return v, e
}
// 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
}
}
func bracketSuffix(x interface{}) p.P {
return func(st p.State) (interface{}, error) {
b, err := p.Try(BracketParser())(st)
if err != nil {
return x, nil
}
return Bracket{x, b.([]interface{})}, nil
}
}
// BracketSuffix 表示带 [] 后缀的表达式
func BracketSuffix(x interface{}) p.P {
return func(st p.State) (interface{}, error) {
b, err := p.Try(BracketParser())(st)
if err != nil {
return nil, err
}
return bracketSuffix(Bracket{x, b.([]interface{})})(st)
}
}
func dotSuffix(x interface{}) p.P {
return func(st p.State) (interface{}, error) {
d, err := p.Try(DotParser)(st)
if err != nil {
return x, nil
}
return dotSuffix(Dot{x, d.(Atom)})(st)
}
}
// AtomParserExt 生成带扩展包的 Atom
func AtomParserExt(env Env) p.P {
return p.Do(func(st p.State) interface{} {
a := atomNameParser().Exec(st)
t, err := p.Try(ExtTypeParser(env)).Parse(st)
if err == nil {
return Atom{a.(string), t.(Type)}
}
return Atom{a.(string), ANYMUST}
})
}
// AtomParser 生成 Atom 对象，但是它不带扩展环境
func AtomParser(st p.State) (interface{}, error) {
a, err := atomNameParser().Parse(st)
if err != nil {
return nil, err
}
t, err := p.Try(TypeParser).Parse(st)
if err == nil {
return Atom{a.(string), t.(Type)}, nil
}
return Atom{a.(string), ANYMUST}, nil
}
// 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
}
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)
}
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)
}
}
// 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
}
}
// addx 实现一个parsex累加解析器，精度向上适配。我一直觉得应该有一个简单的高效版本，不需要回溯的
// 但是目前还没有找到。
func addx(st p.State) (interface{}, error) {
ints, err := p.Try(p.Many(IntValue).Over(p.EOF))(st)
if err == nil {
root := Int(0)
for _, x := range ints.([]interface{}) {
root += x.(Int)
}
return root, nil
}
numbers, err := p.Many(NumberValue).Over(p.EOF)(st)
if err == nil {
root := Float(0)
for _, x := range numbers.([]interface{}) {
root += x.(Float)
}
return root, nil
}
if nerr, ok := err.(NotNumberError); ok {
return nil, TypeSignError{Type: FLOATMUST, Value: nerr.Value}
}
return nil, err
}
// 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
}
}
}
// Parse 解释执行一段文本
func (gisp *Gisp) Parse(code string) (interface{}, error) {
st := p.BasicStateFromText(code)
var v interface{}
var e error
for {
Skip(&st)
_, err := p.Try(p.EOF)(&st)
if err == nil {
break
}
value, err := ValueParserExt(gisp)(&st)
if err != nil {
return nil, err
}
switch lisp := value.(type) {
case Lisp:
v, e = lisp.Eval(gisp)
default:
v = lisp
e = nil
}
}
return v, e
}
// 环境做了妥协
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
}),
// 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
}
}
)(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) {
// 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 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)
// BracketSuffixParser 定义 bracket 表达式判定
func BracketSuffixParser(x interface{}) p.P {
return p.Choice(p.Try(BracketSuffix(x)), p.Return(x))
}
// 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(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)
package gisp
import (
"fmt"
p "github.com/Dwarfartisan/goparsec2"
)
// 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 {
}
}), nil
},
"eof": ParsecBox(p.EOF),
"nil": ParsecBox(p.Nil),
"atimex": ParsecBox(TimeValue),
"try": func(env Env, args ...interface{}) (Lisp, error) {
if len(args) != 1 {
return nil, fmt.Errorf("Parsex Parser Try Error: only accept one parsex parser as arg but %v", args)
}
param, err := Eval(env, args[0])
if err != nil {
return nil, err
}
switch parser := param.(type) {
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
},
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))