static void EGfree (void *compiled_pattern) { struct compiled_regex *cregex = (struct compiled_regex *) compiled_pattern; dfafree (&cregex->dfa); free (cregex->patterns); free (cregex->ckwset.trans); free (cregex); }
void release_regex (struct regex *regex) { if (regex->dfa) { dfafree (regex->dfa); free (regex->dfa); regex->dfa = NULL; } regfree (®ex->pattern); free (regex); }
void refree(Regexp *rp) { free(rp->pat.buffer); free(rp->pat.fastmap); if (rp->regs.start) free(rp->regs.start); if (rp->regs.end) free(rp->regs.end); if (rp->dfa) dfafree(&(rp->dfareg)); free(rp); }
void dispose_fast_regex( struct fast_regex * fre_t ) { struct _fregex * fre = (struct _fregex *)( fre_t->data ) ; if( HAS_REGEX( fre_t->options ) ) { fre->regex.translate = NULL ; regfree( &fre->regex ) ; } if( HAS_DFA( fre_t->options ) ) dfafree( &fre->dfa ) ; if( fre->kwset ) kwsfree( fre->kwset ) ; }
void refree(Regexp *rp) { /* * This isn't malloced, don't let regfree free it. * (This is strictly necessary only for the old * version of regex, but it's a good idea to keep it * here in case regex internals change in the future.) */ rp->pat.translate = NULL; regfree(& rp->pat); if (rp->regs.start) free(rp->regs.start); if (rp->regs.end) free(rp->regs.end); if (rp->dfa) dfafree(&(rp->dfareg)); free(rp); }
int match_regex (struct regex *regex, char *buf, size_t buflen, size_t buf_start_offset, struct re_registers *regarray, int regsize) { int ret; static struct regex *regex_last; /* printf ("Matching from %d/%d\n", buf_start_offset, buflen); */ /* Keep track of the last regexp matched. */ if (!regex) { regex = regex_last; if (!regex_last) bad_prog (_(NO_REGEX)); } else regex_last = regex; /* gnulib's re_search uses signed-int as length */ if (buflen >= INT_MAX) panic (_("regex input buffer length larger than INT_MAX")); if (regex->pattern.no_sub && regsize) { /* Re-compiling an existing regex, free the previously allocated structures. */ if (regex->dfa) { dfafree (regex->dfa); free (regex->dfa); regex->dfa = NULL; } regfree (®ex->pattern); compile_regex_1 (regex, regsize); } regex->pattern.regs_allocated = REGS_REALLOCATE; /* Optimized handling for '^' and '$' patterns */ if (regex->begline || regex->endline) { size_t offset; if (regex->endline) { const char *p = NULL; if (regex->flags & REG_NEWLINE) p = memchr (buf + buf_start_offset, buffer_delimiter, buflen - buf_start_offset); offset = p ? p - buf : buflen; } else if (buf_start_offset == 0) /* begline anchor, starting at beginning of the buffer. */ offset = 0; else if (!(regex->flags & REG_NEWLINE)) /* begline anchor, starting in the middle of the text buffer, and multiline regex is not specified - will never match. Example: seq 2 | sed 'N;s/^/X/g' */ return 0; else if (buf[buf_start_offset - 1] == buffer_delimiter) /* begline anchor, starting in the middle of the text buffer, with multiline match, and the current character is the line delimiter - start here. Example: seq 2 | sed 'N;s/^/X/mg' */ offset = buf_start_offset; else { /* begline anchor, starting in the middle of the search buffer, all previous optimizions didn't work: search for the next line delimiter character in the buffer, and start from there if found. */ const char *p = memchr (buf + buf_start_offset, buffer_delimiter, buflen - buf_start_offset); if (p == NULL) return 0; offset = p - buf + 1; } if (regsize) { size_t i; if (!regarray->start) { regarray->start = XCALLOC (1, regoff_t); regarray->end = XCALLOC (1, regoff_t); regarray->num_regs = 1; } regarray->start[0] = offset; regarray->end[0] = offset; for (i = 1 ; i < regarray->num_regs; ++i) regarray->start[i] = regarray->end[i] = -1; } return 1; } if (buf_start_offset == 0) { struct dfa *superset = dfasuperset (regex->dfa); if (superset && !dfaexec (superset, buf, buf + buflen, true, NULL, NULL)) return 0; if ((!regsize && (regex->flags & REG_NEWLINE)) || (!superset && dfaisfast (regex->dfa))) { bool backref = false; if (!dfaexec (regex->dfa, buf, buf + buflen, true, NULL, &backref)) return 0; if (!regsize && (regex->flags & REG_NEWLINE) && !backref) return 1; } } /* If the buffer delimiter is not newline character, we cannot use newline_anchor flag of regex. So do it line-by-line, and add offset value to results. */ if ((regex->flags & REG_NEWLINE) && buffer_delimiter != '\n') { const char *beg, *end; const char *start; beg = buf; if (buf_start_offset > 0) { const char *eol = memrchr (buf, buffer_delimiter, buf_start_offset); if (eol != NULL) beg = eol + 1; } start = buf + buf_start_offset; for (;;) { end = memchr (beg, buffer_delimiter, buf + buflen - beg); if (end == NULL) end = buf + buflen; ret = re_search (®ex->pattern, beg, end - beg, start - beg, end - start, regsize ? regarray : NULL); if (ret > -1) { size_t i; ret += beg - buf; if (regsize) { for (i = 0; i < regarray->num_regs; ++i) { if (regarray->start[i] > -1) regarray->start[i] += beg - buf; if (regarray->end[i] > -1) regarray->end[i] += beg - buf; } } break; } if (end == buf + buflen) break; beg = start = end + 1; } } else ret = re_search (®ex->pattern, buf, buflen, buf_start_offset, buflen - buf_start_offset, regsize ? regarray : NULL); return (ret > -1); }
int compile_fast_regex( fast_regex_t * fre_t, const char * sre, size_t len ) { struct _fregex * fre = (struct _fregex *)( fre_t->data ) ; int errval ; char * errstr ; int sublen ; char * substr ; errval = 0 ; /* fprintf( stderr, "compile_fast_regex( %p[%p] , %s )\n", fre_t, fre->kwset, sre ) ; */ if( fast_regex_subsys_error == NULL ) fast_regex_subsys_error = fprintf_error ; if( fre_t->options & FRE_STRING_SEARCH ) { if( fre_t->options & FRE_NO_KWSET ) { return -1 ; } /* * straight string match * 'sre' represents a series of newline separated strings to search for */ while( sre ) { substr = strchr( sre, '\n' ) ; if( substr == NULL ) sublen = len ; else sublen = (substr - sre) ; errstr = kwsincr( fre->kwset, sre, sublen ); if( errstr ) { errval = (*fast_regex_subsys_error)( "kwset" , errstr ) ; if( errval ) return errval ; } else fre->num_exact_kws ++ ; len -= (sublen+1) ; sre = (substr) ? (substr + 1) : NULL ; } errstr = kwsprep( fre->kwset ); if( errstr ) { errval = (*fast_regex_subsys_error)( "kwset", errstr ) ; if( errval ) return errval ; } return 0 ; } if( HAS_DFA(fre_t->options) || HAS_KWSET(fre_t->options) ) { dfasyntax( RE_SYNTAX_GREP | RE_HAT_LISTS_NOT_NEWLINE, ( fre_t->options & FRE_CASE_INSENSITIVE ) ) ; dfacomp( sre, len, &(fre->dfa), 1 ) ; if( HAS_KWSET(fre_t->options) ) { errval = build_kws_from_dfa( fre ) ; if( fre_t->options & FRE_NO_DFA ) { /* We used the DFA only to get the keywords */ dfafree( &(fre->dfa) ); } } else { fre->kwset = 0 ; } } if( errval ) return errval ; if( HAS_REGEX(fre_t->options) ) { re_set_syntax(RE_SYNTAX_GREP | RE_HAT_LISTS_NOT_NEWLINE); errstr = re_compile_pattern( sre, len, &(fre->regex) ) ; if( errstr ) { errval = (*fast_regex_subsys_error)( "re", errstr ) ; if( errval ) return errval ; } } return errval ; }