Esempio n. 1
0
func testParser(t *testing.T, name, rules, input string, debug bool) {
	s := syms.NewSymbolSet()
	l := lexer.NewLexer(&s)
	l.Ignore(syms.WS)
	// l.Ignore(syms.EOL)

	functions := make(map[string]grammar.UserFn)
	functions[""] = grammar.DefaultUserFn
	if debug {
		functions[""] = grammar.RuleUserFn
	}

	g, err := grammar.NewGrammarBlock(l, rules, functions)
	if !tlog.Ok(err) {
		t.Fatal(err)
	}

	p, err := NewParserExt(g, debug, false)
	if !tlog.Ok(err) {
		t.Fatal(err)
	}
	p.debug = debug
	l.SetReader(strings.NewReader(input))
	if parse, err := p.Parse(l); tlog.Ok(err) {
		if debug {
			t.Errorf("Successful parse: %v\n", parse)
		} else {
			t.Logf("Successful parse: %v\n", parse)
		}
	} else {
		t.Logf("Partial parse: %v\n", parse)
		t.Fatal(err)
	}
}
Esempio n. 2
0
func TestGrammarHelper(t *testing.T) {
	s := syms.NewSymbolSet()
	l := lexer.NewLexer(&s)

	functions := make(map[string]UserFn)
	functions["buildFunc"] = DefaultUserFn

	grammar := `
		Func → "func" IDENT '(' ')' '{' Stat '}'	@buildFunc
		Stat → NUM | HEXNUM							@raiseFirst
	`

	if g, err := NewGrammarBlock(l, grammar, functions); !tlog.Ok(err) {
		tlog.Println("Grammar: ", g)
		t.Fatal("Cannot create grammar: ", err)
	} else if g.Rules.Size() == 0 {
		t.Fatal("Empty grammar")
	}
}
Esempio n. 3
0
func Parse(r io.Reader) nex.Nex {
	if l == nil {
		s = syms.NewSymbolSet()
		l = lexer.NewLexer(&s)
		l.Ignore(syms.WS)

		functions = make(map[string]grammar.UserFn)
		functions[""] = nexBuilder
		functions["synth"] = nexBuilder
		functions["nil"] = nilHandler
		var err error
		g, err = grammar.NewGrammarBlock(l, readGrammar(), functions)
		if !tlog.Ok(err) {
			return nex.NewErrorNex(err)
		}

		p, err = parser.NewParserExt(g, false, false)
		if !tlog.Ok(err) {
			return nex.NewErrorNex(err)
		}
	}

	l.SetReader(r)
	pt, err := p.Parse(l)
	if err != nil {
		_, isParseError := err.(parser.UnexpectedTerminalParseError)
		if !isParseError {
			return nex.NewErrorNex(err)
		}
	}

	n, isNex := pt.(nex.Nex)
	if !isNex {
		n = makeNexFromArray(g, g.Rules.Get(0), pt)
	}

	return n
}
Esempio n. 4
0
func TestGrammarBasic(t *testing.T) {
	s := syms.NewSymbolSet()
	l := lexer.NewLexer(&s)

	NUM := s.MustGetByName("NUM")
	STAR := l.Operator("*")
	PLUS := l.Operator("+")
	E := s.MustAdd("E", false)
	B := s.MustAdd("B", false)

	grammar := []Rule{
		Rule{E, []syms.SymbolID{E, STAR, B}, DefaultUserFn},
		Rule{E, []syms.SymbolID{E, PLUS, B}, DefaultUserFn},
		Rule{E, []syms.SymbolID{B}, DefaultUserFn},
		Rule{B, []syms.SymbolID{NUM}, DefaultUserFn},
	}
	if g, err := NewGrammar(l.GetSymbolSet(), grammar); !tlog.Ok(err) {
		tlog.Println("Grammar: ", g)
		t.Fatal("Cannot create grammar: ", err)
	} else if g.Rules.Size() == 0 {
		t.Fatal("Empty grammar")
	}
}
Esempio n. 5
0
func TestParseBasic(t *testing.T) {
	s := syms.NewSymbolSet()
	l := lexer.NewLexer(&s)
	l.Ignore(syms.WS)
	l.Ignore(syms.EOL)

	NUM := s.MustGetByName("NUM")
	STAR := l.Operator("*")
	PLUS := l.Operator("+")
	E := l.GetSymbolSet().MustAdd("E", false)
	B := l.GetSymbolSet().MustAdd("B", false)

	rules := []grammar.Rule{
		grammar.Rule{LHS: E, RHS: []syms.SymbolID{E, STAR, B}, UserFn: grammar.StringUserFn},
		grammar.Rule{LHS: E, RHS: []syms.SymbolID{E, PLUS, B}, UserFn: grammar.StringUserFn},
		grammar.Rule{LHS: E, RHS: []syms.SymbolID{B}, UserFn: grammar.StringUserFn},
		grammar.Rule{LHS: B, RHS: []syms.SymbolID{NUM}, UserFn: grammar.StringUserFn},
	}
	g, err := grammar.NewGrammar(&s, rules)
	if !tlog.Ok(err) {
		t.Fatal("Cannot create grammar: ", err)
	}
	p, err := NewParser(g)
	if !tlog.Ok(err) {
		t.Fatal("Cannot create parser from grammar:", err)
	}

	input := `1 + 1`
	l.SetReader(strings.NewReader(input))
	if parse, err := p.Parse(l); tlog.Ok(err) {
		// t.Errorf("Successful parse: %v\n", parse)
		t.Logf("Successful parse: %v\n", parse)
	} else {
		t.Logf("Partial parse: %v\n", parse)
		t.Fatal(err)
	}
}