Ejemplo n.º 1
0
// 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))
		}

	}
}
Ejemplo n.º 2
0
// 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))
		}
	}
}
Ejemplo n.º 3
0
// 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
	}
}
Ejemplo n.º 4
0
// 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)
	}
}
Ejemplo n.º 5
0
// 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)
}
Ejemplo n.º 6
0
// 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
}
Ejemplo n.º 7
0
// 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
	}
}
Ejemplo n.º 8
0
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
}
Ejemplo n.º 9
0
// 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
	}
}
Ejemplo n.º 10
0
// 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
	}
}
Ejemplo n.º 11
0
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)
}
Ejemplo n.º 12
0
// 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
}
Ejemplo n.º 13
0
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)
	}
}
Ejemplo n.º 14
0
func objectBodyParser(st p.State) (interface{}, error) {
	return p.SepBy1(ValueParser(), p.Choice(Colon))(st)
}
Ejemplo n.º 15
0
	)(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) {
Ejemplo n.º 16
0
			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)
Ejemplo n.º 17
0
// BracketSuffixParser 定义 bracket 表达式判定
func BracketSuffixParser(x interface{}) p.P {
	return p.Choice(p.Try(BracketSuffix(x)), p.Return(x))
}
Ejemplo n.º 18
0
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)
Ejemplo n.º 19
0
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
Ejemplo n.º 20
0
// 环境做了妥协
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
		}),
Ejemplo n.º 21
0
			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))
			}
Ejemplo n.º 22
0
		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))