示例#1
0
文件: type.go 项目: zy02636/gisp
func stop(st p.ParseState) (interface{}, error) {
	pos := st.Pos()
	defer st.SeekTo(pos)
	r, err := p.Choice(
		p.Try(p.Space),
		p.Try(p.NewLine),
		p.Try(p.OneOf(":.()[]{}?")),
		p.Try(p.Eof),
	)(st)
	if err != nil {
		return nil, err
	}
	return r, nil
}
示例#2
0
文件: parses.go 项目: zy02636/gisp
func ValueParser(st p.ParseState) (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.Bind(AtomParser, SuffixParser)),
		p.Try(p.Bind(ListParser, SuffixParser)),
		p.Try(DotExprParser),
		QuoteParser,
	)(st)
	return value, err
}
示例#3
0
文件: suffix.go 项目: gale320/gisp
// BracketSuffix 表示带 [] 后缀的表达式
func BracketSuffix(x interface{}) p.Parser {
	return func(st p.ParseState) (interface{}, error) {
		b, err := p.Try(BracketParser)(st)
		if err != nil {
			return nil, err
		}
		return bracketSuffix(Bracket{x, b.([]interface{})})(st)
	}
}
示例#4
0
文件: suffix.go 项目: gale320/gisp
func dotSuffix(x interface{}) p.Parser {
	return func(st p.ParseState) (interface{}, error) {
		d, err := p.Try(DotParser)(st)
		if err != nil {
			return x, nil
		}
		return dotSuffix(Dot{x, d.(Atom)})(st)
	}
}
示例#5
0
文件: suffix.go 项目: gale320/gisp
// SuffixParser 定义了后缀表达式的通用判定
func SuffixParser(prefix interface{}) p.Parser {
	suffix := p.Either(p.Try(DotSuffix(prefix)), BracketSuffix(prefix))
	return func(st p.ParseState) (interface{}, error) {
		s, err := suffix(st)
		if err != nil {
			return prefix, nil
		}
		return SuffixParser(s)(st)
	}
}
示例#6
0
文件: atom.go 项目: gale320/gisp
// AtomParser 生成 Atom 对象,但是它不带扩展环境
func AtomParser(st p.ParseState) (interface{}, error) {
	a, err := atomNameParser(st)
	if err != nil {
		return nil, err
	}
	t, err := p.Try(TypeParser)(st)
	if err == nil {
		return Atom{a.(string), t.(Type)}, nil
	}
	return Atom{a.(string), ANYMUST}, nil
}
示例#7
0
文件: parses.go 项目: gale320/gisp
// QuoteParser 实现 Quote 语法的解析
func QuoteParser(st p.ParseState) (interface{}, error) {
	lisp, err := p.Bind_(p.Rune('\''),
		p.Choice(
			p.Try(p.Bind(AtomParser, SuffixParser)),
			p.Bind(ListParser, SuffixParser),
		))(st)
	if err == nil {
		return Quote{lisp}, nil
	}
	return nil, err
}
示例#8
0
文件: float.go 项目: gale320/gisp
// FloatParser 解析浮点数
func FloatParser(st p.ParseState) (interface{}, error) {
	f, err := p.Try(p.Float)(st)
	if err == nil {
		val, err := strconv.ParseFloat(f.(string), 64)
		if err == nil {
			return Float(val), nil
		}
		return nil, err
	}
	return nil, err
}
示例#9
0
文件: atom.go 项目: zy02636/gisp
func AtomParserExt(env Env) p.Parser {
	return func(st p.ParseState) (interface{}, error) {
		a, err := atomNameParser(st)
		if err != nil {
			return nil, err
		}
		t, err := p.Try(ExtTypeParser(env))(st)
		if err == nil {
			return Atom{a.(string), t.(Type)}, nil
		} else {
			return Atom{a.(string), ANYMUST}, nil
		}
	}
}
示例#10
0
文件: type.go 项目: zy02636/gisp
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
	}
}
示例#11
0
文件: type.go 项目: zy02636/gisp
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
}
示例#12
0
文件: type.go 项目: zy02636/gisp
	)(st)
	if err != nil {
		return nil, err
	}
	return r, nil
}

func stopWord(x interface{}) p.Parser {
	return p.Bind_(stop, p.Return(x))
}

func typeName(word string) p.Parser {
	return p.Bind(p.String(word), stopWord)
}

var anyType = p.Bind(p.Bind(p.Many1(p.Either(p.Try(p.Digit), p.Letter)), stopWord), p.ReturnString)

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 MapTypeParserExt(env Env) p.Parser {
	return func(st p.ParseState) (interface{}, error) {
		key, err := p.Between(p.String("map["), p.Rune(']'), ExtTypeParser(env))(st)
		if err != nil {
示例#13
0
文件: parses.go 项目: zy02636/gisp
			return '\'', nil
		case '\\':
			return '\\', nil
		case 't':
			return '\t', nil
		default:
			return nil, st.Trap("Unknown escape sequence \\%c", r)
		}
	} else {
		return nil, err
	}
})

var RuneParser = p.Bind(
	p.Between(p.Rune('\''), p.Rune('\''),
		p.Either(p.Try(EscapeCharr), p.NoneOf("'"))),
	func(x interface{}) p.Parser {
		return p.Return(Rune(x.(rune)))
	},
)

var StringParser = p.Bind(
	p.Between(p.Rune('"'), p.Rune('"'),
		p.Many(p.Either(p.Try(EscapeChars), p.NoneOf("\"")))),
	p.ReturnString)

func bodyParser(st p.ParseState) (interface{}, error) {
	value, err := p.SepBy(ValueParser, p.Many1(Space))(st)
	return value, err
}
示例#14
0
文件: parsec.go 项目: gale320/gisp
		"anyone": ParsecBox(p.AnyRune),
		"int":    ParsecBox(p.Int),
		"float":  ParsecBox(p.Float),
		"digit":  ParsecBox(p.Digit),
		"eof":    ParsecBox(p.Eof),
		"try": func(env Env, args ...interface{}) (Lisp, error) {
			if len(args) != 1 {
				return nil, ParsexSignErrorf("Parsec Parser Try Error: only accept one Parsec 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, ParsexSignErrorf(
					"Try Arg Error:except 1 parser arg but %v.",
					reflect.TypeOf(param))
			}

		},
		"either": func(env Env, args ...interface{}) (Lisp, error) {
			ptype := reflect.TypeOf((px.Parser)(nil))
			params, err := GetArgs(env, px.UnionAll(TypeAs(ptype), TypeAs(ptype), px.Eof), args)
			if err != nil {
				return nil, err
			}
			return ParsecBox(p.Either(params[0].(Parsecer).Parser, params[1].(Parsecer).Parser)), nil
		},
示例#15
0
文件: suffix.go 项目: gale320/gisp
// BracketSuffixParser 定义 bracket 表达式判定
func BracketSuffixParser(x interface{}) p.Parser {
	return p.Either(p.Try(BracketSuffix(x)), p.Return(x))
}