Esempio n. 1
0
func TestGenerateTests(t *testing.T) {
	type test struct {
		pattern string
		name    string
	}
	tests := []test{
		{"abcdef", "literal"},
		{"[a-z]", "CharClass"},
		{"a*", "star"},
		{"a?", "quest"},
		{"a+", "plus"},
		{"(abc|def)", "alternatives"},
		{"a{1,3}", "repeat1"},
		{"a{0,3}", "repeat2"},
		{"ab+c", "concat"},
		{"^a", "StartOfText"},
		{"^", "StartOfTextEmpty"},
		{"a$", "EndOfText"},
		{"(?m)^a", "StartOfLine"},
		{"(?m)^", "StartOfLineEmpty"},
		{"(?m)a$", "EndOfLine"},
		{`a\b`, "WordBoundary"},
		{`a??`, "lazy1"},
		{`a??b`, "lazy2"},
		{`a*?`, "lazy3"},
		{`a*?b`, "lazy4"},
		{`a+?`, "lazy5"},
		{`a+?b`, "lazy6"},
		{`ab??c`, "lazy7"},
		{`(?i)aZ`, "IgnoreCase1"},
		{`(?i)[a-z]`, "IgnoreCase2"},
	}
	for _, tst := range tests {
		nfanode, err := nfa.New(tst.pattern)
		if err != nil {
			t.Error(err)
		} else {
			node := dfa.NewFromNFA(nfanode)
			source := GoGenerate(node, "test", "match"+uppercaseInitial(tst.name), "string")
			err := writeToFile("test/"+strings.ToLower(tst.name)+".go", source)
			if err != nil {
				t.Error(err)
			}
		}
	}
}
Esempio n. 2
0
func main() {
	log.SetFlags(0)

	output := flag.String("o", "", "Output to file")
	flag.Usage = func() {
		fmt.Println(`Usage: re2dfa [options] regexp package.function string|[]byte

Options:
    -o FILE    Output to FILE instead of standard output

EXAMPLE: re2dfa ^a+$ main.matchAPlus string
`)
	}
	flag.Parse()
	if len(flag.Args()) != 3 {
		flag.Usage()
		os.Exit(1)
	}

	expr := flag.Arg(0)
	_, err := regexp.Compile(expr)
	if err != nil {
		log.Fatal(fmt.Sprintf("invalid regexp: %q", expr))
	}

	pkgfun := strings.Split(flag.Arg(1), ".")
	if len(pkgfun) != 2 {
		flag.Usage()
		os.Exit(1)
	}
	pkg := pkgfun[0]
	fun := pkgfun[1]
	typ := flag.Arg(2)

	if !(typ == "string" || typ == "[]byte") {
		flag.Usage()
		os.Exit(1)
	}

	nfanode, err := nfa.New(expr)
	if err != nil {
		log.Fatal(err)
	}

	node := dfa.NewFromNFA(nfanode)
	source := codegen.GoGenerate(node, pkg, fun, typ)
	if *output == "" {
		fmt.Println(source)
	} else {
		f, err := os.Create(*output)
		if err != nil {
			log.Fatal(err)
		}

		_, err = f.WriteString(source)
		if err != nil {
			log.Fatal(err)
		}

		err = f.Close()
		if err != nil {
			log.Fatal(err)
		}
	}
}