func TestParsecBasic(t *testing.T) {
g := NewGispWith(
map[string]Toolbox{
"axiom": Axiom, "props": Propositions, "time": Time},
map[string]Toolbox{"time": Time, "p": Parsec})
digit := p.Bind(p.Many1(p.Digit), p.ReturnString)
data := "344932454094325"
state := p.MemoryParseState(data)
pre, err := digit(state)
if err != nil {
t.Fatalf("except \"%v\" pass test many1 digit but error:%v", data, err)
}
src := "(let ((st (p.state \"" + data + `")))
(var data ((p.many1 p.digit) st))
(p.s2str data))
`
gre, err := g.Parse(src)
if err != nil {
t.Fatalf("except \"%v\" pass gisp many1 digit but error:%v", src, err)
}
t.Logf("from gisp: %v", gre)
t.Logf("from parsec: %v", pre)
if !reflect.DeepEqual(pre, gre) {
t.Fatalf("except got \"%v\" from gisp equal \"%v\" from parsec", gre, pre)
}
}
func TestParsecRune2(t *testing.T) {
g := NewGispWith(
map[string]Toolbox{
"axiom": Axiom, "props": Propositions, "time": Time},
map[string]Toolbox{"time": Time, "p": Parsec})
//data := "Here is a Rune : 'a' and a is't a rune. It is a word in sentence."
data := "'a' and a is't a rune. It is a word in sentence."
state := p.MemoryParseState(data)
pre, err := p.Between(p.Rune('\''), p.Rune('\''), p.AnyRune)(state)
if err != nil {
t.Fatalf("except found rune expr from \"%v\" but error:%v", data, err)
}
src := `
(let ((st (p.state "` + data + `")))
((p.rune '\'') st)
(var data (p.anyone st))
((p.rune '\'') st)
data)
`
//fmt.Println(src)
gre, err := g.Parse(src)
if err != nil {
t.Fatalf("except \"%v\" pass gisp '<rune>' but error:%v", src, err)
}
t.Logf("from gisp: %v", gre)
t.Logf("from parsec: %v", pre)
if !reflect.DeepEqual(pre, gre) {
t.Fatalf("except got \"%v\" from gisp equal \"%v\" from parsec", gre, pre)
}
}
func TestIntParser3(t *testing.T) {
data := "3.14"
st := p.MemoryParseState(data)
o, err := p.Bind_(IntParser, p.Eof)(st)
if err == nil {
t.Fatalf("except a Float parse error but got %v", o)
}
}
func TestFloatParser5(t *testing.T) {
data := "234"
st := p.MemoryParseState(data)
o, err := FloatParser(st)
if err == nil {
t.Fatalf("except a Float parse error but got %v", o)
}
}
func TestIntParser1(t *testing.T) {
data := "i234"
st := p.MemoryParseState(data)
o, err := IntParser(st)
if err == nil {
t.Fatalf("except a Int parse error but got %v", o)
}
}
func TestDotParser(t *testing.T) {
data := "now.Year"
st := p.MemoryParseState(data)
re, err := p.Bind(AtomParser, DotSuffixParser)(st)
if err != nil {
t.Fatalf("except a Dot but error %v", err)
}
t.Log(re)
}
func atomNameParser(st p.ParseState) (interface{}, error) {
ret, err := p.Bind(p.Many1(p.NoneOf("'[]() \t\r\n\".:")),
p.ReturnString)(st)
if err != nil {
return nil, err
}
test := p.MemoryParseState(ret.(string))
_, err = p.Bind_(p.Many1(p.Digit), p.Eof)(test)
if err == nil {
return nil, fmt.Errorf("atom name can't be a int like %s", ret.(string))
}
return ret, nil
}
func TestAtomParse0(t *testing.T) {
data := "x"
state := p.MemoryParseState(data)
a, err := AtomParser(state)
if err == nil {
test := Atom{"x", Type{ANY, false}}
if !reflect.DeepEqual(test, a) {
t.Fatalf("except Atom{\"x\", ANY} but %v", a)
}
} else {
t.Fatalf("except Atom{\"x\", ANY} but %v", err)
}
}
func TestingBoolParse0(t *testing.T) {
data := "true"
st := p.MemoryParseState(data)
o, err := BoolParser(st)
if err != nil {
t.Fatalf("except bool but error %v", err)
}
if b, ok := o.(Bool); ok {
if !b {
t.Fatalf("except bool true but %v", b)
}
} else {
t.Fatalf("excpet bool but %v", o)
}
}
func TestFloatParser0(t *testing.T) {
data := "0.012"
st := p.MemoryParseState(data)
o, err := FloatParser(st)
if err != nil {
t.Fatalf("except a Float but error %v", err)
}
if f, ok := o.(Float); ok {
if f != Float(0.012) {
t.Fatalf("except a Float 0.012 but %v", f)
}
} else {
t.Fatalf("except Float but %v", o)
}
}
func TestFloatParser1(t *testing.T) {
data := "3.1415926"
st := p.MemoryParseState(data)
o, err := FloatParser(st)
if err != nil {
t.Fatalf("except a Float but error %v", err)
}
if f, ok := o.(Float); ok {
if f != Float(3.1415926) {
t.Fatalf("except a Float 3.1415926 but %v", f)
}
} else {
t.Fatalf("except Float but %v", o)
}
}
func TestIntParser0(t *testing.T) {
data := "12"
st := p.MemoryParseState(data)
o, err := IntParser(st)
if err != nil {
t.Fatalf("except a Int but error %v", err)
}
if i, ok := o.(Int); ok {
if i != Int(12) {
t.Fatalf("except a Int 12 but %v", i)
}
} else {
t.Fatalf("except Int but %v", o)
}
}
// Parse 解释执行一段文本
func (gisp *Gisp) Parse(code string) (interface{}, error) {
st := p.MemoryParseState(code)
var v interface{}
var e error
for {
Skip(st)
_, err := 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
}
Meta: map[string]interface{}{
"name": "parsex",
"category": "package",
},
Content: map[string]interface{}{
"state": func(env Env, args ...interface{}) (Lisp, error) {
if len(args) != 1 {
return nil, ParsexSignErrorf("Parsex Arg Error:except args has 1 arg.")
}
param, err := Eval(env, args[0])
if err != nil {
return nil, err
}
switch data := param.(type) {
case string:
return Q(p.MemoryParseState(data)), nil
default:
return nil, fmt.Errorf("Parsex Error: Except create a state from a string or List but %v", data)
}
},
"s2str": func(env Env, args ...interface{}) (Lisp, error) {
if len(args) != 1 {
return nil, ParsexSignErrorf("Slice to string Arg Error:except args has 1 arg.")
}
param, err := Eval(env, args[0])
if err != nil {
return nil, err
}
var (
slice []interface{}
ok bool