1/*********************************************************************** 2* * 3* This software is part of the ast package * 4* Copyright (c) 1985-2012 AT&T Intellectual Property * 5* and is licensed under the * 6* Eclipse Public License, Version 1.0 * 7* by AT&T Intellectual Property * 8* * 9* A copy of the License is available at * 10* http://www.eclipse.org/org/documents/epl-v10.html * 11* (with md5 checksum b35adb5213ca9657e911e9befb180842) * 12* * 13* Information and Software Systems Research * 14* AT&T Research * 15* Florham Park NJ * 16* * 17* Glenn Fowler <gsf@research.att.com> * 18* David Korn <dgk@research.att.com> * 19* Phong Vo <kpv@research.att.com> * 20* * 21***********************************************************************/ 22#pragma prototyped 23 24/* 25 * D. G. Korn 26 * G. S. Fowler 27 * AT&T Research 28 * 29 * match shell file patterns 30 * this interface is a wrapper on regex 31 * 32 * sh pattern egrep RE description 33 * ---------- -------- ----------- 34 * * .* 0 or more chars 35 * ? . any single char 36 * [.] [.] char class 37 * [!.] [^.] negated char class 38 * [[:.:]] [[:.:]] ctype class 39 * [[=.=]] [[=.=]] equivalence class 40 * [[...]] [[...]] collation element 41 * *(.) (.)* 0 or more of 42 * +(.) (.)+ 1 or more of 43 * ?(.) (.)? 0 or 1 of 44 * (.) (.) 1 of 45 * @(.) (.) 1 of 46 * a|b a|b a or b 47 * \# () subgroup back reference [1-9] 48 * a&b a and b 49 * !(.) none of 50 * 51 * \ used to escape metacharacters 52 * 53 * *, ?, (, |, &, ), [, \ must be \'d outside of [...] 54 * only ] must be \'d inside [...] 55 * 56 */ 57 58#include <ast.h> 59#include <regex.h> 60 61static struct State_s 62{ 63 regmatch_t* match; 64 int nmatch; 65} matchstate; 66 67#define STR_INT 040000 68 69/* 70 * subgroup match 71 * 0 returned if no match 72 * otherwise number of subgroups matched returned 73 * match group begin offsets are even elements of sub 74 * match group end offsets are odd elements of sub 75 * the matched string is from s+sub[0] up to but not 76 * including s+sub[1] 77 */ 78 79int 80strgrpmatch(const char* b, const char* p, ssize_t* sub, int n, register int flags) 81{ 82 register regex_t* re; 83 register ssize_t* end; 84 register int i; 85 register regflags_t reflags; 86 87 /* 88 * 0 and empty patterns are special 89 */ 90 91 if (!p || !b) 92 { 93 if (!p && !b) 94 regcache(NiL, 0, NiL); 95 return 0; 96 } 97 if (!*p) 98 { 99 if (sub && n > 0) 100 { 101 if (flags & STR_INT) 102 { 103 int* subi = (int*)sub; 104 105 subi[0] = subi[1] = 0; 106 } 107 else 108 sub[0] = sub[1] = 0; 109 } 110 return *b == 0; 111 } 112 113 /* 114 * convert flags 115 */ 116 117 if (flags & REG_ADVANCE) 118 reflags = flags & ~REG_ADVANCE; 119 else 120 { 121 reflags = REG_SHELL|REG_AUGMENTED; 122 if (!(flags & STR_MAXIMAL)) 123 reflags |= REG_MINIMAL; 124 if (flags & STR_GROUP) 125 reflags |= REG_SHELL_GROUP; 126 if (flags & STR_LEFT) 127 reflags |= REG_LEFT; 128 if (flags & STR_RIGHT) 129 reflags |= REG_RIGHT; 130 if (flags & STR_ICASE) 131 reflags |= REG_ICASE; 132 } 133 if (!sub || n <= 0) 134 reflags |= REG_NOSUB; 135 if (!(re = regcache(p, reflags, NiL))) 136 return 0; 137 if (n > matchstate.nmatch) 138 { 139 if (!(matchstate.match = newof(matchstate.match, regmatch_t, n, 0))) 140 return 0; 141 matchstate.nmatch = n; 142 } 143 if (regexec(re, b, n, matchstate.match, reflags & ~(REG_MINIMAL|REG_SHELL_GROUP|REG_LEFT|REG_RIGHT|REG_ICASE))) 144 return 0; 145 if (!sub || n <= 0) 146 return 1; 147 i = re->re_nsub; 148 if (flags & STR_INT) 149 { 150 int* subi = (int*)sub; 151 int* endi = subi + n * 2; 152 153 for (n = 0; subi < endi && n <= i; n++) 154 { 155 *subi++ = matchstate.match[n].rm_so; 156 *subi++ = matchstate.match[n].rm_eo; 157 } 158 } 159 else 160 { 161 end = sub + n * 2; 162 for (n = 0; sub < end && n <= i; n++) 163 { 164 *sub++ = matchstate.match[n].rm_so; 165 *sub++ = matchstate.match[n].rm_eo; 166 } 167 } 168 return i + 1; 169} 170 171/* 172 * compare the string s with the shell pattern p 173 * returns 1 for match 0 otherwise 174 */ 175 176int 177strmatch(const char* s, const char* p) 178{ 179 return strgrpmatch(s, p, NiL, 0, STR_MAXIMAL|STR_LEFT|STR_RIGHT); 180} 181 182/* 183 * leading substring match 184 * first char after end of substring returned 185 * 0 returned if no match 186 * 187 * OBSOLETE: use strgrpmatch() 188 */ 189 190char* 191strsubmatch(const char* s, const char* p, int flags) 192{ 193 ssize_t match[2]; 194 195 return strgrpmatch(s, p, match, 1, (flags ? STR_MAXIMAL : 0)|STR_LEFT) ? (char*)s + match[1] : (char*)0; 196} 197 198#undef strgrpmatch 199#if _map_libc 200#define strgrpmatch _ast_strgrpmatch 201#endif 202 203int 204strgrpmatch(const char* b, const char* p, int* sub, int n, int flags) 205{ 206 return strgrpmatch_20120528(b, p, (ssize_t*)sub, n, flags|STR_INT); 207} 208