static void compile_regexp(struct grep_pat *p, struct grep_opt *opt) { int err; p->word_regexp = opt->word_regexp; p->ignore_case = opt->ignore_case; if (opt->fixed || is_fixed(p->pattern, p->patternlen)) p->fixed = 1; else p->fixed = 0; if (p->fixed) { if (opt->regflags & REG_ICASE || p->ignore_case) p->kws = kwsalloc(tolower_trans_tbl); else p->kws = kwsalloc(NULL); kwsincr(p->kws, p->pattern, p->patternlen); kwsprep(p->kws); return; } if (opt->pcre) { compile_pcre_regexp(p, opt); return; } err = regcomp(&p->regexp, p->pattern, opt->regflags); if (err) { char errbuf[1024]; regerror(err, &p->regexp, errbuf, 1024); regfree(&p->regexp); compile_regexp_failed(p, errbuf); } }
static void diffcore_pickaxe_count(struct diff_options *o) { const char *needle = o->pickaxe; int opts = o->pickaxe_opts; unsigned long len = strlen(needle); regex_t regex, *regexp = NULL; kwset_t kws = NULL; if (opts & DIFF_PICKAXE_REGEX) { int err; err = regcomp(®ex, needle, REG_EXTENDED | REG_NEWLINE); if (err) { /* The POSIX.2 people are surely sick */ char errbuf[1024]; regerror(err, ®ex, errbuf, 1024); regfree(®ex); die("invalid pickaxe regex: %s", errbuf); } regexp = ®ex; } else { kws = kwsalloc(DIFF_OPT_TST(o, PICKAXE_IGNORE_CASE) ? tolower_trans_tbl : NULL); kwsincr(kws, needle, len); kwsprep(kws); } pickaxe(&diff_queued_diff, o, regexp, kws, has_changes); if (opts & DIFF_PICKAXE_REGEX) regfree(®ex); else kwsfree(kws); return; }
int allocate_fast_regex ( fast_regex_t * fre_t ) { struct _fregex * fre = (struct _fregex*)( malloc( sizeof(struct _fregex) ) ) ; fre_t->data = fre ; /* fprintf( stderr, "allocate_fast_regex( %p : %p, %p, %p, %hu, %lu )\n", fre_t , &fre->regex, &fre->dfa, fre->kwset, fre->num_exact_kws, fre->options ) ; */ if( !(ichars['A']) ) build_ichars() ; /* fprintf( stderr, "(bi) - allocate_fast_regex( %p[%p] )\n", fre_t , fre->kwset ) ; */ if( HAS_KWSET(fre_t->options) ) fre->kwset = kwsalloc( (fre_t->options & FRE_CASE_INSENSITIVE) ? ichars : NULL ) ; else fre->kwset = NULL ; fre->num_exact_kws = 0 ; /* fprintf( stderr, "(kw) - allocate_fast_regex( %p[%p] )\n", fre_t , fre->kwset ) ; */ if( HAS_DFA(fre_t->options) ) dfainit( &(fre->dfa) ); /* fprintf( stderr, "(df) - allocate_fast_regex( %p[%p] )\n", fre_t , fre->kwset ) ; */ if( HAS_REGEX(fre_t->options) ) { fre->regex.allocated = 0 ; fre->regex.buffer = NULL ; fre->regex.fastmap = NULL ; if ( fre_t->options & FRE_CASE_INSENSITIVE ) fre->regex.translate = ichars ; else fre->regex.translate = NULL ; } /* fprintf( stderr, "(re) - allocate_fast_regex( %p[%p] )\n", fre_t , fre->kwset ) ; */ return 0 ; }
static void compile_regexp(struct grep_pat *p, struct grep_opt *opt) { int icase, ascii_only; int err; p->word_regexp = opt->word_regexp; p->ignore_case = opt->ignore_case; icase = opt->regflags & REG_ICASE || p->ignore_case; ascii_only = !has_non_ascii(p->pattern); /* * Even when -F (fixed) asks us to do a non-regexp search, we * may not be able to correctly case-fold when -i * (ignore-case) is asked (in which case, we'll synthesize a * regexp to match the pattern that matches regexp special * characters literally, while ignoring case differences). On * the other hand, even without -F, if the pattern does not * have any regexp special characters and there is no need for * case-folding search, we can internally turn it into a * simple string match using kws. p->fixed tells us if we * want to use kws. */ if (opt->fixed || is_fixed(p->pattern, p->patternlen)) p->fixed = !icase || ascii_only; else p->fixed = 0; if (p->fixed) { p->kws = kwsalloc(icase ? tolower_trans_tbl : NULL); kwsincr(p->kws, p->pattern, p->patternlen); kwsprep(p->kws); return; } else if (opt->fixed) { /* * We come here when the pattern has the non-ascii * characters we cannot case-fold, and asked to * ignore-case. */ compile_fixed_regexp(p, opt); return; } if (opt->pcre) { compile_pcre_regexp(p, opt); return; } err = regcomp(&p->regexp, p->pattern, opt->regflags); if (err) { char errbuf[1024]; regerror(err, &p->regexp, errbuf, 1024); regfree(&p->regexp); compile_regexp_failed(p, errbuf); } }
void kwsinit (kwset_t *kwset) { static char trans[NCHAR]; int i; if (match_icase #if MBS_SUPPORT && MB_CUR_MAX == 1 #endif ) { for (i = 0; i < NCHAR; ++i) trans[i] = tolower (i); *kwset = kwsalloc (trans); } else *kwset = kwsalloc (NULL); if (!*kwset) xalloc_die (); }
void diffcore_pickaxe(struct diff_options *o) { const char *needle = o->pickaxe; int opts = o->pickaxe_opts; regex_t regex, *regexp = NULL; kwset_t kws = NULL; if (opts & (DIFF_PICKAXE_REGEX | DIFF_PICKAXE_KIND_G)) { int cflags = REG_EXTENDED | REG_NEWLINE; if (o->pickaxe_opts & DIFF_PICKAXE_IGNORE_CASE) cflags |= REG_ICASE; regcomp_or_die(®ex, needle, cflags); regexp = ®ex; } else if (opts & DIFF_PICKAXE_KIND_S) { if (o->pickaxe_opts & DIFF_PICKAXE_IGNORE_CASE && has_non_ascii(needle)) { struct strbuf sb = STRBUF_INIT; int cflags = REG_NEWLINE | REG_ICASE; basic_regex_quote_buf(&sb, needle); regcomp_or_die(®ex, sb.buf, cflags); strbuf_release(&sb); regexp = ®ex; } else { kws = kwsalloc(o->pickaxe_opts & DIFF_PICKAXE_IGNORE_CASE ? tolower_trans_tbl : NULL); kwsincr(kws, needle, strlen(needle)); kwsprep(kws); } } pickaxe(&diff_queued_diff, o, regexp, kws, (opts & DIFF_PICKAXE_KIND_G) ? diff_grep : has_changes); if (regexp) regfree(regexp); if (kws) kwsfree(kws); return; }