Golang StringVector.Data方法代码示例

// GenerateTestMain returns the source code for a test program that will run
// the specified test functions from the specified package.
func GenerateTestMain(packageName string, funcs *set.StringSet) string {
	var funcVec vector.StringVector
	for val := range funcs.Iter() {
		funcVec.Push(val)
	}

	result := ""
	result += "package main\n\n"
	result += "import \"testing\"\n"

	if funcVec.Len() > 0 {
		result += fmt.Sprintf("import \"./%s\"\n\n", packageName)
	}

	result += "var tests = []testing.Test {\n"
	for _, val := range funcVec.Data() {
		result += fmt.Sprintf("\ttesting.Test{\"%s\", %s.%s},\n", val, packageName, val)
	}

	result += "}\n\n"
	result += "func main() {\n"
	result += "\ttesting.Main(tests)\n"
	result += "}\n"

	return result
}

func getSorted(set *StringSet) []string {
	var sorted vector.StringVector
	for val := range set.Iter() {
		sorted.Push(val)
	}

	sort.SortStrings(sorted)
	return sorted.Data()
}

func (self *Regex) Matches(s string) []string {
	res := new(vector.StringVector)
	self.l.StartString(s)
	for !self.l.Eof() {
		if self.l.Next() == 0 {
			res.Push(self.l.String())
		}
	}
	return res.Data()
}

func expectContentsEqual(t *testing.T, set *set.StringSet, expected []string) {
	var contents vector.StringVector
	for val := range set.Iter() {
		contents.Push(val)
	}

	sort.SortStrings(contents)
	sort.SortStrings(expected)

	if !reflect.DeepEqual(contents.Data(), expected) {
		t.Errorf("Expected:%v\nGot: %v", expected, contents)
	}
}

func (p *MatchRule) _ToString() string {
	svec := new(vector.StringVector)

	v := reflect.Indirect(reflect.NewValue(p)).(*reflect.StructValue)
	t := v.Type().(*reflect.StructType)
	for i := 0; i < v.NumField(); i++ {
		str, ok := v.Field(i).Interface().(string)
		if ok && "" != str {
			svec.Push(fmt.Sprintf("%s='%s'", strings.ToLower(t.Field(i).Name), str))
		}
	}

	return strings.Join(svec.Data(), ",")
}

func (self *Regex) Replace(s string, f func(string) string) string {
	res := new(vector.StringVector)
	buf := bytes.Runes([]byte(s))
	last := 0
	self.l.StartString(s)
	for !self.l.Eof() {
		if self.l.Next() == 0 {
			res.Push(string(buf[last:self.l.Pos()]))
			res.Push(f(self.l.String()))
			last = self.l.Pos() + self.l.Len()
		}
	}
	res.Push(string(buf[last:]))
	return strings.Join(res.Data(), "")
}

// linkBinary calls 6l to link the binary of the given name, which must have
// already been compiled with compileFiles.
func linkBinary(name string) {
	linkerName, ok := linkers[os.Getenv("GOARCH")]
	if !ok {
		fmt.Println("Could not determine the correct linker to run.")
		fmt.Println("Please ensure that $GOARCH is set.")
		os.Exit(1)
	}

	linkerPath := path.Join(os.Getenv("GOBIN"), linkerName)

	var linkerArgs vector.StringVector
	linkerArgs.Push("-o")
	linkerArgs.Push(name)
	linkerArgs.Push(name + "." + linkerName[0:1])

	if !executeCommand(linkerPath, linkerArgs.Data(), "igo-out/") {
		os.Exit(1)
	}
}

// compileFiles invokes 6g with the appropriate arguments for compiling the
// supplied set of .go files, and exits the program if the subprocess fails.
func compileFiles(files *set.StringSet, targetBaseName string) {
	compilerName, ok := compilers[os.Getenv("GOARCH")]
	if !ok {
		fmt.Println("Could not determine the correct compiler to run.")
		fmt.Println("Please ensure that $GOARCH is set.")
		os.Exit(1)
	}

	compilerPath := path.Join(os.Getenv("GOBIN"), compilerName)
	gopackPath := path.Join(os.Getenv("GOBIN"), "gopack")

	targetDir, _ := path.Split(targetBaseName)
	if targetDir != "" {
		os.MkdirAll(path.Join("igo-out", targetDir), 0700)
	}

	// Compile
	var compilerArgs vector.StringVector
	compilerArgs.Push("-o")
	compilerArgs.Push(targetBaseName + ".6")

	for file := range files.Iter() {
		compilerArgs.Push(path.Join("../", file))
	}

	if !executeCommand(compilerPath, compilerArgs.Data(), "igo-out/") {
		os.Exit(1)
	}

	// Pack
	var gopackArgs vector.StringVector
	gopackArgs.Push("grc")
	gopackArgs.Push(targetBaseName + ".a")
	gopackArgs.Push(targetBaseName + ".6")

	if !executeCommand(gopackPath, gopackArgs.Data(), "igo-out/") {
		os.Exit(1)
	}
}

func Parse(line string) *Message {
	m := &Message{}
	matches := re.MatchStrings(line)
	if len(matches) != 4 {
		return nil
	}

	prefix, command, params := matches[1], matches[2], matches[3]
	if len(prefix) > 2 {
		m.Prefix = prefix[1 : len(prefix)-1]
	}
	m.Command = strings.ToUpper(command)

	paramArray := new(vector.StringVector)
	param := ""
	for i, c := range params {
		switch {
		case c == ' ':
			if param != "" {
				paramArray.Push(param)
				param = ""
			}
		case c == ':' && param == "":
			paramArray.Push(params[i+1 : len(params)])
			goto done
		default:
			param += string(c)
		}
	}
	if param != "" {
		paramArray.Push(param)
		param = ""
	}
done:
	m.Params = paramArray.Data()
	return m
}

// executeCommand runs the specified tool with the supplied arguments (not
// including the path to the tool itself), chdir'ing to the specified directory
// first. It returns true if and only if the child process returns zero.
func executeCommand(tool string, args []string, dir string) bool {
	fmt.Printf("%s %s\n", tool, strings.Join(args, " "))

	var fullArgs vector.StringVector
	fullArgs.Push(tool)
	fullArgs.AppendVector(&args)

	pid, err := os.ForkExec(
		tool,
		fullArgs.Data(),
		os.Environ(),
		dir,
		[]*os.File{os.Stdin, os.Stdout, os.Stderr})
	if err != nil {
		panic(err)
	}

	waitMsg, err := os.Wait(pid, 0)
	if err != nil {
		panic(err)
	}

	return waitMsg.ExitStatus() == 0
}

func join(sv *vector.StringVector, sep string) string {
	return strings.Join(sv.Data(), sep)
}

func main() {
	sqlite3.Initialize()
	defer func() {
		log.Stdout("closing sqlite3")
		sqlite3.Shutdown()
	}()

	dbh := new(sqlite3.Handle)
	dbh.Open("bbs.db")
	defer dbh.Close()

	InitTables(dbh)

	flag.Parse()
	templ := func() *template.Template {
		templateStr, err := io.ReadFile("tmpl/top.tmpl")
		if err != nil {
			log.Exit(err)
		}
		return template.MustParse(string(templateStr), nil)
	}()

	http.Handle("/", http.HandlerFunc(func(c *http.Conn, req *http.Request) {
		params := new(struct{ msgs []string })
		storage := new(vector.StringVector)
		func() {
			st, err := dbh.Prepare("SELECT * from entry ORDER BY id DESC limit 30;")
			func() {
				if err != "" {
					log.Exit(err)
				}
				for {
					rv := st.Step()
					switch {
					case rv == sqlite3.SQLITE_DONE:
						return
					case rv == sqlite3.SQLITE_ROW:
						body := st.ColumnText(1)
						storage.Push(body)
					default:
						println(rv)
						log.Exit(dbh.ErrMsg())
					}
				}
			}()
			if st.Finalize() != sqlite3.SQLITE_OK {
				log.Exit(dbh.ErrMsg())
			}
		}()
		params.msgs = storage.Data()
		err := templ.Execute(params, c)
		if err != nil {
			log.Exit("templ.Execute:", err)
		}
	}))
	http.Handle("/post", http.HandlerFunc(func(c *http.Conn, req *http.Request) {
		req.ParseForm()

		body := req.Form["body"][0]
		st, err := dbh.Prepare("INSERT INTO entry (body) VALUES (?)")
		if err != "" {
			log.Exit(err)
		}
		if st.BindText(1, body) != sqlite3.SQLITE_OK {
			log.Exit("cannot bind: ", dbh.ErrMsg())
		}
		if st.Step() != sqlite3.SQLITE_DONE {
			log.Exit(dbh.ErrMsg())
		}
		if st.Finalize() != sqlite3.SQLITE_OK {
			log.Exit(dbh.ErrMsg())
		}

		http.Redirect(c, "/", 302)
	}))
	http.Handle("/css/", http.HandlerFunc(func(c *http.Conn, req *http.Request) {
		http.ServeFile(c, req, "."+req.URL.Path)
	}))

	// run httpd
	func() {
		fmt.Printf("http://%s/\n", *addr)
		err := http.ListenAndServe(*addr, nil)
		if err != nil {
			log.Exit("ListenAndServe:", err)
		}
	}()
}