Golang regexp.CompilePOSIX函数代码示例

func (s *scrape) MapRegex(node xml.Node) (map[string]string, error) {
	if node.IsValid() == false {
		return nil, errors.New("Invalid node")
	}
	m := make(map[string]string, 1)
	inner := node.String()
	for k, v := range ScrapeRegex {
		// remove new line chars
		reg, _ := regexp.CompilePOSIX("\r\n|\r|\n")
		inner = reg.ReplaceAllString(inner, "")
		// get the real data
		reg, _ = regexp.CompilePOSIX(v[0])
		scraped := reg.FindString(inner)
		scraped = reg.ReplaceAllString(scraped, "$1")

		if scraped != "" {
			m[k] = scraped
		}
	}
	// Skip empty and unwanted
	if len(m) > 0 {
		if m[ScrapeMeta[IGNOREEMPTY]] != "" {
			return m, nil
		}
		return nil, nil
	}
	return nil, nil
}

func validateHTTPIngressRuleValue(httpIngressRuleValue *extensions.HTTPIngressRuleValue, fldPath *field.Path) field.ErrorList {
	allErrs := field.ErrorList{}
	if len(httpIngressRuleValue.Paths) == 0 {
		allErrs = append(allErrs, field.Required(fldPath.Child("paths"), ""))
	}
	for i, rule := range httpIngressRuleValue.Paths {
		if len(rule.Path) > 0 {
			if !strings.HasPrefix(rule.Path, "/") {
				allErrs = append(allErrs, field.Invalid(fldPath.Child("paths").Index(i).Child("path"), rule.Path, "must be an absolute path"))
			}
			// TODO: More draconian path regex validation.
			// Path must be a valid regex. This is the basic requirement.
			// In addition to this any characters not allowed in a path per
			// RFC 3986 section-3.3 cannot appear as a literal in the regex.
			// Consider the example: http://host/valid?#bar, everything after
			// the last '/' is a valid regex that matches valid#bar, which
			// isn't a valid path, because the path terminates at the first ?
			// or #. A more sophisticated form of validation would detect that
			// the user is confusing url regexes with path regexes.
			_, err := regexp.CompilePOSIX(rule.Path)
			if err != nil {
				allErrs = append(allErrs, field.Invalid(fldPath.Child("paths").Index(i).Child("path"), rule.Path, "must be a valid regex"))
			}
		}
		allErrs = append(allErrs, validateIngressBackend(&rule.Backend, fldPath.Child("backend"))...)
	}
	return allErrs
}

func filterSingleDir(path string, data []os.FileInfo) ([]os.FileInfo, error) {
	reg, err := regexp.CompilePOSIX(Config.fileregex)
	if err != nil {
		return nil, err
	}

	//搜索出生成文件
	genfile := GetGenerateFileName(path)

	//过滤出需要生成的文件
	newdata := []os.FileInfo{}
	var genfiledata os.FileInfo
	for _, singleFileInfo := range data {
		if singleFileInfo.Name() == genfile {
			genfiledata = singleFileInfo
			continue
		}
		if reg.Match([]byte(path+"/"+singleFileInfo.Name())) == false {
			continue
		}
		newdata = append(newdata, singleFileInfo)
	}

	//判断是否需要生成文件
	for _, singleFileInfo := range newdata {
		if genfiledata == nil || singleFileInfo.ModTime().After(genfiledata.ModTime()) {
			return newdata, nil
		}
	}

	//FIXME 暂时不做增量更新策略
	return newdata, nil
}

//从rawurl中提取顶级域名服务商,tldTop用来查询，topDomain用来找注册商服务器，domainName用来查询的域名
func Extract_tld(rawurl string) (tldTop, topDomain, domainName string) {
	filename := "./res/data.txt"
	data := openfile(filename)
	host := extract_host(rawurl)
	host_slice := strings.Split(host, ".")
	length := len(host_slice)
	tldTop = host_slice[length-1]
	// fmt.Println(tldTop)
	//得到顶级域名和主机名
	for i := 0; i < length; i++ {
		expr := ""
		for j := i; j < length; j++ {
			expr = expr + "." + host_slice[j]
		}

		reg, _ := regexp.CompilePOSIX("^" + expr[1:])
		// reg, _ := regexp.CompilePOSIX("^" + expr[1:] + "$")
		if reg.MatchString(data) {
			if i != 0 {
				domainName = host_slice[i-1] + expr
			} else {
				domainName = expr
			}
			topDomain = expr[1:]
			return
		}
	}
	return
}

func NewTerm(kind TKind_t, lfactor *Factor, list *List, rfactor *Factor, expr *Expr) (*Term, error) {
	t := new(Term)
	t.Kind = kind
	switch kind {
	case IN, NI:
		t.Left = lfactor
		t.Right = list
	case GT, LT, EQ, NE, GE, LE:
		t.Left = lfactor
		t.Right = rfactor
	case MA, NM:
		t.Left = lfactor
		if v, err := cast2string(rfactor.Value); err != nil {
			return t, err
		} else {
			if t.Right, err = regexp.CompilePOSIX(v); err != nil {
				return t, err
			}
		}
	case EXPR:
		t.Left = nil
		t.Right = expr
	}
	return t, nil
}

func (s *StreamServer) GetRegexp() (map[string][]*regexp.Regexp, error) {
	consulSetting := make(map[string][]*regexp.Regexp)
	kv := s.client.KV()
	pairs, _, err := kv.List(s.ConsulKey, nil)
	if err != nil {
		return consulSetting, err
	}
	size := len(s.ConsulKey) + 1
	for _, value := range pairs {
		if len(value.Key) > size {
			var regs []string
			if err := json.Unmarshal(value.Value, &regs); err == nil {
				var rs []*regexp.Regexp
				for _, v := range regs {
					x, e := regexp.CompilePOSIX(v)
					if e != nil {
						log.Println("get regexp", e)
						continue
					}
					rs = append(rs, x)
				}
				consulSetting[value.Key[size:]] = rs
			}
		}
	}
	return consulSetting, err
}

func main() {
	var re *regexp.Regexp
	var err error
	visited := newVisitTracker()
	if *filter != "" {
		re, err = regexp.CompilePOSIX(*filter)
		if err != nil {
			log.Fatal("Failed to compile regex", err)
		}
	}

	url, err := url.ParseRequestURI(*webRoot)
	if err != nil {
		log.Fatal("Invalid root URL:", err)
	}
	host = url.Scheme + "://" + url.Host

	//probe root page
	rootPage, err := getPage(*webRoot)
	if err != nil {
		log.Fatal("Failed to get root page", err)
	}

	urls := extractURLs(rootPage)
	walkUrls(visited, urls, *webRoot, re, *ft)
}

// NewPOSIX complies the provided POSIX regex.
func NewPOSIX(regex string) (*Regexp, error) {
	re, err := regexp.CompilePOSIX(regex)
	if err != nil {
		return nil, err
	}

	return &Regexp{RE: re}, nil
}

//ie,ru顶级域名处理函数，注册人提取，无电话邮箱
func ieManage(details string) (regName, regPhone, regEmail string) {
	re, _ := regexp.CompilePOSIX("person:.*|registrar:.*|Registrar Name:.*")
	regName = re.FindString(details)
	if len(regName) != 0 {
		regName = strings.TrimSpace(strings.Split(regName, ":")[1])
	}
	return
}

func (e *Excludes) Set(value string) error {
	r, err := regexp.CompilePOSIX(value)
	if err == nil {
		*e = append(*e, *r)
	} else {
		log.Error("Error:", err.Error())
	}

	return nil
}

func (c *Condition) AddRegexp(r map[string]string) error {

	for field, value := range r {
		reg, err := regexp.CompilePOSIX(value)
		if err != nil {
			return err
		}
		c.Regexp[field] = reg
	}
	return nil
}

// TODO: Move this into a Windows specific build function and
//       make unix a no-op
func LinuxPath(path string) string {
	// Strip drive prefix c:/ etc.
	// TODO: Need to find a way to deal with paths properly (i.e. what if multiple drives!)
	r, _ := regexp.CompilePOSIX("([a-zA-Z]:)(\\.*)")
	if r.MatchString(path) {
		path = r.ReplaceAllString(path, "$2")
	}

	path = strings.Replace(path, "\\", "/", -1)
	path = strings.Replace(path, "//", "/", -1)
	return path
}

func compile(pattern string, options GrepOptions) (*regexp.Regexp, error) {
	if options.IsPerl {
		if options.IsIgnoreCase && !strings.HasPrefix(pattern, "(?") {
			pattern = "(?i)" + pattern
		}
		return regexp.Compile(pattern)
	} else {
		if options.IsIgnoreCase {
			pattern = strings.ToLower(pattern)
		}
		return regexp.CompilePOSIX(pattern)
	}
}

func main() {
	flag.Parse()

	if *showVersionShort || *showVersionLong {
		fmt.Println("0.2")
		return
	}

	conf, err := sup.NewSupfile(*supfile)
	if err != nil {
		log.Fatal(err)
	}

	// Parse network and commands to be run from args.
	network, commands, err := parseArgs(conf)
	if err != nil {
		log.Fatal(err)
	}

	// --only option to filter hosts
	if *onlyHosts != "" {
		expr, err := regexp.CompilePOSIX(*onlyHosts)
		if err != nil {
			log.Fatal(err)
		}

		var hosts []string
		for _, host := range network.Hosts {
			if expr.MatchString(host) {
				hosts = append(hosts, host)
			}
		}
		if len(hosts) == 0 {
			log.Fatal(fmt.Errorf("no hosts match '%v' regexp", *onlyHosts))
		}
		network.Hosts = hosts
	}

	// Create new Stackup app.
	app, err := sup.New(conf)
	if err != nil {
		log.Fatal(err)
	}

	// Run all the commands in the given network.
	err = app.Run(network, commands...)
	if err != nil {
		log.Fatal(err)
	}
}

// InitRegexps initializes a list of compiled regular expressions.
func InitRegexps(exprs []string) ([]*regexp.Regexp, error) {

	result := []*regexp.Regexp{}

	for _, exp := range exprs {

		rexp, err := regexp.CompilePOSIX(exp)
		if err != nil {
			logp.Err("Fail to compile the regexp %s: %s", exp, err)
			return nil, err
		}
		result = append(result, rexp)
	}
	return result, nil
}