![[BACK]](/icons/back.gif){kind=icon}
Return to pattern.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / less|
Return to pattern.c CVS log | Up to [local] / src / usr.bin / less |
1.1 ! shadchin 1: /*
! 2: * Copyright (C) 1984-2011 Mark Nudelman
! 3: *
! 4: * You may distribute under the terms of either the GNU General Public
! 5: * License or the Less License, as specified in the README file.
! 6: *
! 7: * For more information about less, or for information on how to
! 8: * contact the author, see the README file.
! 9: */
! 10:
! 11: /*
! 12: * Routines to do pattern matching.
! 13: */
! 14:
! 15: #include "less.h"
! 16: #include "pattern.h"
! 17:
! 18: extern int caseless;
! 19:
! 20: /*
! 21: * Compile a search pattern, for future use by match_pattern.
! 22: */
! 23: static int
! 24: compile_pattern2(pattern, search_type, comp_pattern)
! 25: char *pattern;
! 26: int search_type;
! 27: void **comp_pattern;
! 28: {
! 29: if ((search_type & SRCH_NO_REGEX) == 0)
! 30: {
! 31: #if HAVE_POSIX_REGCOMP
! 32: regex_t *comp = (regex_t *) ecalloc(1, sizeof(regex_t));
! 33: regex_t **pcomp = (regex_t **) comp_pattern;
! 34: if (regcomp(comp, pattern, REGCOMP_FLAG))
! 35: {
! 36: free(comp);
! 37: error("Invalid pattern", NULL_PARG);
! 38: return (-1);
! 39: }
! 40: if (*pcomp != NULL)
! 41: regfree(*pcomp);
! 42: *pcomp = comp;
! 43: #endif
! 44: #if HAVE_PCRE
! 45: pcre *comp;
! 46: pcre **pcomp = (pcre **) comp_pattern;
! 47: const char *errstring;
! 48: int erroffset;
! 49: PARG parg;
! 50: comp = pcre_compile(pattern, 0,
! 51: &errstring, &erroffset, NULL);
! 52: if (comp == NULL)
! 53: {
! 54: parg.p_string = (char *) errstring;
! 55: error("%s", &parg);
! 56: return (-1);
! 57: }
! 58: *pcomp = comp;
! 59: #endif
! 60: #if HAVE_RE_COMP
! 61: PARG parg;
! 62: int *pcomp = (int *) comp_pattern;
! 63: if ((parg.p_string = re_comp(pattern)) != NULL)
! 64: {
! 65: error("%s", &parg);
! 66: return (-1);
! 67: }
! 68: *pcomp = 1;
! 69: #endif
! 70: #if HAVE_REGCMP
! 71: char *comp;
! 72: char **pcomp = (char **) comp_pattern;
! 73: if ((comp = regcmp(pattern, 0)) == NULL)
! 74: {
! 75: error("Invalid pattern", NULL_PARG);
! 76: return (-1);
! 77: }
! 78: if (pcomp != NULL)
! 79: free(*pcomp);
! 80: *pcomp = comp;
! 81: #endif
! 82: #if HAVE_V8_REGCOMP
! 83: struct regexp *comp;
! 84: struct regexp **pcomp = (struct regexp **) comp_pattern;
! 85: if ((comp = regcomp(pattern)) == NULL)
! 86: {
! 87: /*
! 88: * regcomp has already printed an error message
! 89: * via regerror().
! 90: */
! 91: return (-1);
! 92: }
! 93: if (*pcomp != NULL)
! 94: free(*pcomp);
! 95: *pcomp = comp;
! 96: #endif
! 97: }
! 98: return (0);
! 99: }
! 100:
! 101: /*
! 102: * Like compile_pattern2, but convert the pattern to lowercase if necessary.
! 103: */
! 104: public int
! 105: compile_pattern(pattern, search_type, comp_pattern)
! 106: char *pattern;
! 107: int search_type;
! 108: void **comp_pattern;
! 109: {
! 110: char *cvt_pattern;
! 111: int result;
! 112:
! 113: if (caseless != OPT_ONPLUS)
! 114: cvt_pattern = pattern;
! 115: else
! 116: {
! 117: cvt_pattern = (char*) ecalloc(1, cvt_length(strlen(pattern), CVT_TO_LC));
! 118: cvt_text(cvt_pattern, pattern, (int *)NULL, (int *)NULL, CVT_TO_LC);
! 119: }
! 120: result = compile_pattern2(cvt_pattern, search_type, comp_pattern);
! 121: if (cvt_pattern != pattern)
! 122: free(cvt_pattern);
! 123: return (result);
! 124: }
! 125:
! 126: /*
! 127: * Forget that we have a compiled pattern.
! 128: */
! 129: public void
! 130: uncompile_pattern(pattern)
! 131: void **pattern;
! 132: {
! 133: #if HAVE_POSIX_REGCOMP
! 134: regex_t **pcomp = (regex_t **) pattern;
! 135: if (*pcomp != NULL)
! 136: regfree(*pcomp);
! 137: *pcomp = NULL;
! 138: #endif
! 139: #if HAVE_PCRE
! 140: pcre **pcomp = (pcre **) pattern;
! 141: if (*pcomp != NULL)
! 142: pcre_free(*pcomp);
! 143: *pcomp = NULL;
! 144: #endif
! 145: #if HAVE_RE_COMP
! 146: int *pcomp = (int *) pattern;
! 147: *pcomp = 0;
! 148: #endif
! 149: #if HAVE_REGCMP
! 150: char **pcomp = (char **) pattern;
! 151: if (*pcomp != NULL)
! 152: free(*pcomp);
! 153: *pcomp = NULL;
! 154: #endif
! 155: #if HAVE_V8_REGCOMP
! 156: struct regexp **pcomp = (struct regexp **) pattern;
! 157: if (*pcomp != NULL)
! 158: free(*pcomp);
! 159: *pcomp = NULL;
! 160: #endif
! 161: }
! 162:
! 163: /*
! 164: * Is a compiled pattern null?
! 165: */
! 166: public int
! 167: is_null_pattern(pattern)
! 168: void *pattern;
! 169: {
! 170: #if HAVE_POSIX_REGCOMP
! 171: return (pattern == NULL);
! 172: #endif
! 173: #if HAVE_PCRE
! 174: return (pattern == NULL);
! 175: #endif
! 176: #if HAVE_RE_COMP
! 177: return (pattern == 0);
! 178: #endif
! 179: #if HAVE_REGCMP
! 180: return (pattern == NULL);
! 181: #endif
! 182: #if HAVE_V8_REGCOMP
! 183: return (pattern == NULL);
! 184: #endif
! 185: #if NO_REGEX
! 186: return (search_pattern != NULL);
! 187: #endif
! 188: }
! 189:
! 190: /*
! 191: * Simple pattern matching function.
! 192: * It supports no metacharacters like *, etc.
! 193: */
! 194: static int
! 195: match(pattern, pattern_len, buf, buf_len, pfound, pend)
! 196: char *pattern;
! 197: int pattern_len;
! 198: char *buf;
! 199: int buf_len;
! 200: char **pfound, **pend;
! 201: {
! 202: register char *pp, *lp;
! 203: register char *pattern_end = pattern + pattern_len;
! 204: register char *buf_end = buf + buf_len;
! 205:
! 206: for ( ; buf < buf_end; buf++)
! 207: {
! 208: for (pp = pattern, lp = buf; *pp == *lp; pp++, lp++)
! 209: if (pp == pattern_end || lp == buf_end)
! 210: break;
! 211: if (pp == pattern_end)
! 212: {
! 213: if (pfound != NULL)
! 214: *pfound = buf;
! 215: if (pend != NULL)
! 216: *pend = lp;
! 217: return (1);
! 218: }
! 219: }
! 220: return (0);
! 221: }
! 222:
! 223: /*
! 224: * Perform a pattern match with the previously compiled pattern.
! 225: * Set sp and ep to the start and end of the matched string.
! 226: */
! 227: public int
! 228: match_pattern(pattern, tpattern, line, line_len, sp, ep, notbol, search_type)
! 229: void *pattern;
! 230: char *tpattern;
! 231: char *line;
! 232: int line_len;
! 233: char **sp;
! 234: char **ep;
! 235: int notbol;
! 236: int search_type;
! 237: {
! 238: int matched;
! 239: #if HAVE_POSIX_REGCOMP
! 240: regex_t *spattern = (regex_t *) pattern;
! 241: #endif
! 242: #if HAVE_PCRE
! 243: pcre *spattern = (pcre *) pattern;
! 244: #endif
! 245: #if HAVE_RE_COMP
! 246: int spattern = (int) pattern;
! 247: #endif
! 248: #if HAVE_REGCMP
! 249: char *spattern = (char *) pattern;
! 250: #endif
! 251: #if HAVE_V8_REGCOMP
! 252: struct regexp *spattern = (struct regexp *) pattern;
! 253: #endif
! 254:
! 255: if (search_type & SRCH_NO_REGEX)
! 256: matched = match(tpattern, strlen(tpattern), line, line_len, sp, ep);
! 257: else
! 258: {
! 259: #if HAVE_POSIX_REGCOMP
! 260: {
! 261: regmatch_t rm;
! 262: int flags = (notbol) ? REG_NOTBOL : 0;
! 263: matched = !regexec(spattern, line, 1, &rm, flags);
! 264: if (matched)
! 265: {
! 266: #ifndef __WATCOMC__
! 267: *sp = line + rm.rm_so;
! 268: *ep = line + rm.rm_eo;
! 269: #else
! 270: *sp = rm.rm_sp;
! 271: *ep = rm.rm_ep;
! 272: #endif
! 273: }
! 274: }
! 275: #endif
! 276: #if HAVE_PCRE
! 277: {
! 278: int flags = (notbol) ? PCRE_NOTBOL : 0;
! 279: int ovector[3];
! 280: matched = pcre_exec(spattern, NULL, line, line_len,
! 281: 0, flags, ovector, 3) >= 0;
! 282: if (matched)
! 283: {
! 284: *sp = line + ovector[0];
! 285: *ep = line + ovector[1];
! 286: }
! 287: }
! 288: #endif
! 289: #if HAVE_RE_COMP
! 290: matched = (re_exec(line) == 1);
! 291: /*
! 292: * re_exec doesn't seem to provide a way to get the matched string.
! 293: */
! 294: *sp = *ep = NULL;
! 295: #endif
! 296: #if HAVE_REGCMP
! 297: *ep = regex(spattern, line);
! 298: matched = (*ep != NULL);
! 299: if (matched)
! 300: *sp = __loc1;
! 301: #endif
! 302: #if HAVE_V8_REGCOMP
! 303: #if HAVE_REGEXEC2
! 304: matched = regexec2(spattern, line, notbol);
! 305: #else
! 306: matched = regexec(spattern, line);
! 307: #endif
! 308: if (matched)
! 309: {
! 310: *sp = spattern->startp[0];
! 311: *ep = spattern->endp[0];
! 312: }
! 313: #endif
! 314: #if NO_REGEX
! 315: matched = match(tpattern, strlen(tpattern), line, line_len, sp, ep);
! 316: #endif
! 317: }
! 318: matched = (!(search_type & SRCH_NO_MATCH) && matched) ||
! 319: ((search_type & SRCH_NO_MATCH) && !matched);
! 320: return (matched);
! 321: }
! 322: