bin/pax/pat_rep.c

464

fn_match(char *pattern, char *string, char **pend)

bin/pax/pat_rep.c

471

switch (c = *pattern++) {

bin/pax/pat_rep.c

496

c = *pattern;

bin/pax/pat_rep.c

501

c = *++pattern;

bin/pax/pat_rep.c

513

if (!fn_match(pattern, string, pend))

bin/pax/pat_rep.c

523

((pattern = range_match(pattern, test)) == NULL))

bin/pax/pat_rep.c

537

range_match(char *pattern, int test)

bin/pax/pat_rep.c

544

if ((negate = (*pattern == '!')) != 0)

bin/pax/pat_rep.c

545

++pattern;

bin/pax/pat_rep.c

547

while ((c = *pattern++) != ']') {

bin/pax/pat_rep.c

554

if ((*pattern == '-') && ((c2 = pattern[1]) != '\0') &&

bin/pax/pat_rep.c

558

pattern += 2;

bin/pax/pat_rep.c

562

return (ok == negate ? NULL : pattern);

bin/pax/pax.h

175

struct pattern *fow; /* next pattern */

bin/pax/pax.h

73

typedef struct pattern PATTERN;

bin/sh/eval.c

396

for (patp = cp->nclist.pattern ; patp ; patp = patp->narg.next) {

bin/sh/expand.c

1030

expandmeta(char *pattern, struct arglist *dstlist)

bin/sh/expand.c

1037

p = pattern;

bin/sh/expand.c

1042

expmeta(expdir, pattern, dstlist);

bin/sh/expand.c

1051

rmescapes(pattern);

bin/sh/expand.c

1052

appendarglist(dstlist, pattern);

bin/sh/expand.c

1257

patmatch(const char *pattern, const char *string)

bin/sh/expand.c

1264

p = pattern;

bin/sh/expand.c

1436

casematch(union node *pattern, const char *val)

bin/sh/expand.c

1444

argbackq = pattern->narg.backquote;

bin/sh/expand.c

1446

argstr(pattern->narg.text, &argbackq, EXP_TILDE | EXP_CASE, NULL);

bin/sh/parser.c

534

app = &cp->nclist.pattern;

crypto/heimdal/appl/ftp/ftpd/ftpd.c

2343

find(char *pattern)

crypto/heimdal/appl/ftp/ftpd/ftpd.c

2351

pattern);

crypto/heimdal/appl/ftp/ftpd/ftpd.c

658

match(const char *pattern, const char *string)

crypto/heimdal/appl/ftp/ftpd/ftpd.c

660

return fnmatch(pattern, string, FNM_NOESCAPE);

crypto/heimdal/kuser/klist.c

338

krb5_creds pattern;

crypto/heimdal/kuser/klist.c

343

krb5_cc_clear_mcred(&pattern);

crypto/heimdal/kuser/klist.c

347

ret = krb5_make_principal (context, &pattern.server,

crypto/heimdal/kuser/klist.c

351

pattern.client = principal;

crypto/heimdal/kuser/klist.c

353

ret = krb5_cc_retrieve_cred (context, ccache, 0, &pattern, &creds);

crypto/heimdal/kuser/klist.c

354

krb5_free_principal (context, pattern.server);

crypto/heimdal/lib/krb5/principal.c

1002

krb5_const_principal pattern)

crypto/heimdal/lib/krb5/principal.c

1005

if(princ_num_comp(princ) != princ_num_comp(pattern))

crypto/heimdal/lib/krb5/principal.c

1007

if(fnmatch(princ_realm(pattern), princ_realm(princ), 0) != 0)

crypto/heimdal/lib/krb5/principal.c

1010

if(fnmatch(princ_ncomp(pattern, i), princ_ncomp(princ, i), 0) != 0)

crypto/heimdal/lib/roken/fnmatch.c

108

if (!rk_fnmatch(pattern, string, flags & ~FNM_PERIOD))

crypto/heimdal/lib/roken/fnmatch.c

120

if ((pattern =

crypto/heimdal/lib/roken/fnmatch.c

121

rangematch(pattern, *string, flags)) == NULL)

crypto/heimdal/lib/roken/fnmatch.c

127

if ((c = *pattern++) == EOS) {

crypto/heimdal/lib/roken/fnmatch.c

129

--pattern;

crypto/heimdal/lib/roken/fnmatch.c

142

rangematch(const char *pattern, int test, int flags)

crypto/heimdal/lib/roken/fnmatch.c

154

if (negate = (*pattern == '!' || *pattern == '^'))

crypto/heimdal/lib/roken/fnmatch.c

155

++pattern;

crypto/heimdal/lib/roken/fnmatch.c

157

for (ok = 0; (c = *pattern++) != ']';) {

crypto/heimdal/lib/roken/fnmatch.c

159

c = *pattern++;

crypto/heimdal/lib/roken/fnmatch.c

162

if (*pattern == '-'

crypto/heimdal/lib/roken/fnmatch.c

163

&& (c2 = *(pattern+1)) != EOS && c2 != ']') {

crypto/heimdal/lib/roken/fnmatch.c

164

pattern += 2;

crypto/heimdal/lib/roken/fnmatch.c

166

c2 = *pattern++;

crypto/heimdal/lib/roken/fnmatch.c

174

return (ok == negate ? NULL : pattern);

crypto/heimdal/lib/roken/fnmatch.c

62

rk_fnmatch(const char *pattern, const char *string, int flags)

crypto/heimdal/lib/roken/fnmatch.c

68

switch (c = *pattern++) {

crypto/heimdal/lib/roken/fnmatch.c

83

c = *pattern;

crypto/heimdal/lib/roken/fnmatch.c

86

c = *++pattern;

crypto/heimdal/lib/roken/glob.c

168

glob(const char *pattern,

crypto/heimdal/lib/roken/glob.c

177

patnext = (const u_char *) pattern;

crypto/heimdal/lib/roken/glob.c

219

static int globexp1(const Char *pattern, glob_t *pglob)

crypto/heimdal/lib/roken/glob.c

221

const Char* ptr = pattern;

crypto/heimdal/lib/roken/glob.c

225

if (pattern[0] == CHAR_LBRACE && pattern[1] == CHAR_RBRACE && pattern[2] == CHAR_EOS)

crypto/heimdal/lib/roken/glob.c

226

return glob0(pattern, pglob);

crypto/heimdal/lib/roken/glob.c

229

if (!globexp2(ptr, pattern, pglob, &rv))

crypto/heimdal/lib/roken/glob.c

232

return glob0(pattern, pglob);

crypto/heimdal/lib/roken/glob.c

241

static int globexp2(const Char *ptr, const Char *pattern,

crypto/heimdal/lib/roken/glob.c

250

for (lm = patbuf, pm = pattern; pm != ptr; *lm++ = *pm++)

crypto/heimdal/lib/roken/glob.c

345

globtilde(const Char *pattern, Char *patbuf, glob_t *pglob)

crypto/heimdal/lib/roken/glob.c

352

if (*pattern != CHAR_TILDE || !(pglob->gl_flags & GLOB_TILDE))

crypto/heimdal/lib/roken/glob.c

353

return pattern;

crypto/heimdal/lib/roken/glob.c

356

for (p = pattern + 1, h = (char *) patbuf; *p && *p != CHAR_SLASH;

crypto/heimdal/lib/roken/glob.c

369

return pattern;

crypto/heimdal/lib/roken/glob.c

379

return pattern;

crypto/heimdal/lib/roken/glob.c

404

glob0(const Char *pattern, glob_t *pglob)

crypto/heimdal/lib/roken/glob.c

411

qpatnext = globtilde(pattern, patbuf, pglob);

crypto/heimdal/lib/roken/glob.c

480

return(globextend(pattern, pglob, &limit));

crypto/heimdal/lib/roken/glob.c

494

glob1(Char *pattern, glob_t *pglob, size_t *limit)

crypto/heimdal/lib/roken/glob.c

499

if (*pattern == CHAR_EOS)

crypto/heimdal/lib/roken/glob.c

501

return(glob2(pathbuf, pathbuf, pattern, pglob, limit));

crypto/heimdal/lib/roken/glob.c

519

glob2(Char *pathbuf, Char *pathend, Char *pattern, glob_t *pglob,

crypto/heimdal/lib/roken/glob.c

531

if (*pattern == CHAR_EOS) { /* End of pattern? */

crypto/heimdal/lib/roken/glob.c

550

p = pattern;

crypto/heimdal/lib/roken/glob.c

559

pattern = p;

crypto/heimdal/lib/roken/glob.c

560

while (*pattern == CHAR_SEP)

crypto/heimdal/lib/roken/glob.c

561

*pathend++ = *pattern++;

crypto/heimdal/lib/roken/glob.c

563

return(glob3(pathbuf, pathend, pattern, p, pglob,

crypto/heimdal/lib/roken/glob.c

570

glob3(Char *pathbuf, Char *pathend, Char *pattern, Char *restpattern,

crypto/heimdal/lib/roken/glob.c

612

if (dp->d_name[0] == CHAR_DOT && *pattern != CHAR_DOT)

crypto/heimdal/lib/roken/glob.c

617

if (!match(pathend, pattern, restpattern)) {

crypto/krb5/src/include/k5-platform.h

901

int k5_fnmatch(const char *pattern, const char *string, int flags);

crypto/krb5/src/include/k5-regex.h

102

int k5_regcomp(regex_t *preg, const char *pattern, int flags);

crypto/krb5/src/lib/krb5/ccache/ccselect_k5identity.c

47

fnmatch_data(const char *pattern, krb5_data *data, krb5_boolean fold_case)

crypto/krb5/src/lib/krb5/ccache/ccselect_k5identity.c

64

res = fnmatch(pattern, str, 0);

crypto/krb5/src/plugins/preauth/pkinit/pkinit_srv.c

1239

char *pattern;

crypto/krb5/src/plugins/preauth/pkinit/pkinit_srv.c

1246

"pkinit_cert_match", &pattern);

crypto/krb5/src/plugins/preauth/pkinit/pkinit_srv.c

1249

if (pattern == NULL)

crypto/krb5/src/plugins/preauth/pkinit/pkinit_srv.c

1254

req_opts->reqctx->cryptoctx, pattern,

crypto/krb5/src/plugins/preauth/pkinit/pkinit_srv.c

1256

req_opts->cb->free_string(context, req_opts->rock, pattern);

crypto/krb5/src/util/support/fnmatch.c

103

return ok == negate ? NULL : pattern;

crypto/krb5/src/util/support/fnmatch.c

108

fnmatchx(const char *pattern, const char *string, int flags, size_t recursion)

crypto/krb5/src/util/support/fnmatch.c

113

_DIAGASSERT(pattern != NULL);

crypto/krb5/src/util/support/fnmatch.c

120

switch (c = FOLDCASE(*pattern++, flags)) {

crypto/krb5/src/util/support/fnmatch.c

137

c = FOLDCASE(*pattern, flags);

crypto/krb5/src/util/support/fnmatch.c

140

c = FOLDCASE(*++pattern, flags);

crypto/krb5/src/util/support/fnmatch.c

164

switch ((e = fnmatchx(pattern, string,

crypto/krb5/src/util/support/fnmatch.c

181

if ((pattern = rangematch(pattern,

crypto/krb5/src/util/support/fnmatch.c

188

if ((c = FOLDCASE(*pattern++, flags)) == EOS) {

crypto/krb5/src/util/support/fnmatch.c

190

--pattern;

crypto/krb5/src/util/support/fnmatch.c

204

k5_fnmatch(const char *pattern, const char *string, int flags)

crypto/krb5/src/util/support/fnmatch.c

206

return fnmatchx(pattern, string, flags, 64);

crypto/krb5/src/util/support/fnmatch.c

68

rangematch(const char *pattern, int test, int flags)

crypto/krb5/src/util/support/fnmatch.c

73

_DIAGASSERT(pattern != NULL);

crypto/krb5/src/util/support/fnmatch.c

82

if ((negate = (*pattern == '!' || *pattern == '^')) != 0)

crypto/krb5/src/util/support/fnmatch.c

83

++pattern;

crypto/krb5/src/util/support/fnmatch.c

85

for (ok = 0; (c = FOLDCASE(*pattern++, flags)) != ']';) {

crypto/krb5/src/util/support/fnmatch.c

87

c = FOLDCASE(*pattern++, flags);

crypto/krb5/src/util/support/fnmatch.c

90

if (*pattern == '-'

crypto/krb5/src/util/support/fnmatch.c

91

&& (c2 = FOLDCASE(*(pattern + 1), flags)) != EOS &&

crypto/krb5/src/util/support/fnmatch.c

93

pattern += 2;

crypto/krb5/src/util/support/fnmatch.c

95

c2 = FOLDCASE(*pattern++, flags);

crypto/krb5/src/util/support/regex.cpp

51

k5_regcomp(regex_t *preg, const char *pattern, int cflags)

crypto/krb5/src/util/support/regex.cpp

65

r = new std::regex(pattern, flags);

crypto/openssh/match.c

100

epsilon_closure(states, pattern, M);

crypto/openssh/match.c

109

if (pattern[i] == '*') {

crypto/openssh/match.c

115

} else if (pattern[i] == '?' || pattern[i] == *s) {

crypto/openssh/match.c

125

epsilon_closure(next_states, pattern, M);

crypto/openssh/match.c

161

match_pattern_list(const char *string, const char *pattern, int dolower)

crypto/openssh/match.c

166

u_int i, subi, len = strlen(pattern);

crypto/openssh/match.c

171

if (pattern[i] == '!') {

crypto/openssh/match.c

182

i < len && subi < sizeof(sub) - 1 && pattern[i] != ',';

crypto/openssh/match.c

184

sub[subi] = dolower && isupper((u_char)pattern[i]) ?

crypto/openssh/match.c

185

tolower((u_char)pattern[i]) : pattern[i];

crypto/openssh/match.c

191

if (i < len && pattern[i] == ',')

crypto/openssh/match.c

215

match_usergroup_pattern_list(const char *string, const char *pattern)

crypto/openssh/match.c

219

return cygwin_ug_match_pattern_list(string, pattern);

crypto/openssh/match.c

222

return match_pattern_list(string, pattern, 0);

crypto/openssh/match.c

233

match_hostname(const char *host, const char *pattern)

crypto/openssh/match.c

239

r = match_pattern_list(hostcopy, pattern, 1);

crypto/openssh/match.c

276

const char *pattern)

crypto/openssh/match.c

283

if ((p = strrchr(pattern, '@')) != NULL &&

crypto/openssh/match.c

292

if (strrchr(pattern, '@') == NULL)

crypto/openssh/match.c

293

return match_pattern(user, pattern);

crypto/openssh/match.c

295

pat = xstrdup(pattern);

crypto/openssh/match.c

61

epsilon_closure(char *states, const char *pattern, size_t M)

crypto/openssh/match.c

67

if (!states[i] || pattern[i] != '*')

crypto/openssh/match.c

82

match_pattern(const char *s, const char *pattern)

crypto/openssh/match.c

90

if ((M = strlen(pattern)) == 0)

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

132

__match_pattern (const wchar_t *s, const wchar_t *pattern)

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

136

if (!*pattern)

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

139

if (*pattern == '*') {

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

141

pattern++;

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

144

if (!*pattern)

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

148

if (*pattern != '?' && *pattern != '*') {

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

155

if (*s == *pattern &&

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

156

__match_pattern(s + 1, pattern + 1))

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

166

if (__match_pattern(s, pattern))

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

179

if (*pattern != '?' && towlower(*pattern) != towlower(*s))

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

184

pattern++;

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

190

_match_pattern(const char *s, const char *pattern)

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

201

if ((len = mbstowcs(NULL, pattern, 0)) == (size_t) -1) {

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

206

mbstowcs(wpattern, pattern, len + 1);

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

220

cygwin_ug_match_pattern_list(const char *string, const char *pattern)

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

225

size_t i, subi, len = strlen(pattern);

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

230

if (pattern[i] == '!') {

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

241

i < len && subi < sizeof(sub) - 1 && pattern[i] != ',';

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

243

sub[subi] = pattern[i];

crypto/openssh/openbsd-compat/bsd-cygwin_util.c

249

if (i < len && pattern[i] == ',')

crypto/openssh/openbsd-compat/fnmatch.c

104

classmatch(const char *pattern, char test, int foldcase, const char **ep)

crypto/openssh/openbsd-compat/fnmatch.c

106

const char * const mismatch = pattern;

crypto/openssh/openbsd-compat/fnmatch.c

112

if (pattern[0] != '[' || pattern[1] != ':') {

crypto/openssh/openbsd-compat/fnmatch.c

116

pattern += 2;

crypto/openssh/openbsd-compat/fnmatch.c

118

if ((colon = strchr(pattern, ':')) == NULL || colon[1] != ']') {

crypto/openssh/openbsd-compat/fnmatch.c

123

len = (size_t)(colon - pattern);

crypto/openssh/openbsd-compat/fnmatch.c

125

if (foldcase && strncmp(pattern, "upper:]", 7) == 0)

crypto/openssh/openbsd-compat/fnmatch.c

126

pattern = "lower:]";

crypto/openssh/openbsd-compat/fnmatch.c

128

if (!strncmp(pattern, cc->name, len) && cc->name[len] == '\0') {

crypto/openssh/openbsd-compat/fnmatch.c

149

static int fnmatch_ch(const char **pattern, const char **string, int flags)

crypto/openssh/openbsd-compat/fnmatch.c

151

const char * const mismatch = *pattern;

crypto/openssh/openbsd-compat/fnmatch.c

159

if (**pattern == '[') {

crypto/openssh/openbsd-compat/fnmatch.c

160

++*pattern;

crypto/openssh/openbsd-compat/fnmatch.c

163

negate = (**pattern == '!') || (**pattern == '^');

crypto/openssh/openbsd-compat/fnmatch.c

165

++*pattern;

crypto/openssh/openbsd-compat/fnmatch.c

168

if (**pattern == ']')

crypto/openssh/openbsd-compat/fnmatch.c

171

while (**pattern) {

crypto/openssh/openbsd-compat/fnmatch.c

172

if (**pattern == ']') {

crypto/openssh/openbsd-compat/fnmatch.c

173

++*pattern;

crypto/openssh/openbsd-compat/fnmatch.c

179

if (escape && (**pattern == '\\')) {

crypto/openssh/openbsd-compat/fnmatch.c

180

++*pattern;

crypto/openssh/openbsd-compat/fnmatch.c

183

if (!**pattern)

crypto/openssh/openbsd-compat/fnmatch.c

188

if (slash && (**pattern == '/'))

crypto/openssh/openbsd-compat/fnmatch.c

192

switch (classmatch(*pattern, **string, nocase, pattern)) {

crypto/openssh/openbsd-compat/fnmatch.c

203

if (!**pattern)

crypto/openssh/openbsd-compat/fnmatch.c

211

if (((*pattern)[1] == '-') && ((*pattern)[2] != ']')) {

crypto/openssh/openbsd-compat/fnmatch.c

212

startch = *pattern;

crypto/openssh/openbsd-compat/fnmatch.c

213

*pattern += (escape && ((*pattern)[2] == '\\')) ? 3 : 2;

crypto/openssh/openbsd-compat/fnmatch.c

221

if (!**pattern || (slash && (**pattern == '/')))

crypto/openssh/openbsd-compat/fnmatch.c

225

if ((**string >= *startch) && (**string <= **pattern))

crypto/openssh/openbsd-compat/fnmatch.c

230

isupper((unsigned char)**pattern)) &&

crypto/openssh/openbsd-compat/fnmatch.c

234

tolower((unsigned char)**pattern)))

crypto/openssh/openbsd-compat/fnmatch.c

237

++*pattern;

crypto/openssh/openbsd-compat/fnmatch.c

242

if ((**string == **pattern))

crypto/openssh/openbsd-compat/fnmatch.c

245

isupper((unsigned char)**pattern)) &&

crypto/openssh/openbsd-compat/fnmatch.c

247

tolower((unsigned char)**pattern)))

crypto/openssh/openbsd-compat/fnmatch.c

250

++*pattern;

crypto/openssh/openbsd-compat/fnmatch.c

256

*pattern = mismatch;

crypto/openssh/openbsd-compat/fnmatch.c

258

} else if (**pattern == '?') {

crypto/openssh/openbsd-compat/fnmatch.c

264

} else if (escape && (**pattern == '\\') && (*pattern)[1]) {

crypto/openssh/openbsd-compat/fnmatch.c

265

++*pattern;

crypto/openssh/openbsd-compat/fnmatch.c

269

if (**string == **pattern)

crypto/openssh/openbsd-compat/fnmatch.c

272

isupper((unsigned char)**pattern)) &&

crypto/openssh/openbsd-compat/fnmatch.c

274

tolower((unsigned char)**pattern)))

crypto/openssh/openbsd-compat/fnmatch.c

278

if (**string == '\0' || **pattern == '\0' ||

crypto/openssh/openbsd-compat/fnmatch.c

279

(slash && ((**string == '/') || (**pattern == '/'))))

crypto/openssh/openbsd-compat/fnmatch.c

283

++*pattern;

crypto/openssh/openbsd-compat/fnmatch.c

289

int fnmatch(const char *pattern, const char *string, int flags)

crypto/openssh/openbsd-compat/fnmatch.c

304

if (*pattern == '*')

crypto/openssh/openbsd-compat/fnmatch.c

307

while (*pattern && *string) {

crypto/openssh/openbsd-compat/fnmatch.c

312

if (slash && escape && (*pattern == '\\') && (pattern[1] == '/'))

crypto/openssh/openbsd-compat/fnmatch.c

313

++pattern;

crypto/openssh/openbsd-compat/fnmatch.c

314

if (slash && (*pattern == '/') && (*string == '/')) {

crypto/openssh/openbsd-compat/fnmatch.c

315

++pattern;

crypto/openssh/openbsd-compat/fnmatch.c

325

if (*pattern == '.')

crypto/openssh/openbsd-compat/fnmatch.c

326

++pattern;

crypto/openssh/openbsd-compat/fnmatch.c

327

else if (escape && (*pattern == '\\') && (pattern[1] == '.'))

crypto/openssh/openbsd-compat/fnmatch.c

328

pattern += 2;

crypto/openssh/openbsd-compat/fnmatch.c

350

while (*pattern) {

crypto/openssh/openbsd-compat/fnmatch.c

352

((string == strendseg) && (*pattern != '*')))

crypto/openssh/openbsd-compat/fnmatch.c

355

if (slash && ((*pattern == '/') ||

crypto/openssh/openbsd-compat/fnmatch.c

356

(escape && (*pattern == '\\') && (pattern[1] == '/'))))

crypto/openssh/openbsd-compat/fnmatch.c

363

for (wild = 0; (*pattern == '*') || (*pattern == '?'); ++pattern) {

crypto/openssh/openbsd-compat/fnmatch.c

364

if (*pattern == '*') {

crypto/openssh/openbsd-compat/fnmatch.c

377

mismatch = pattern;

crypto/openssh/openbsd-compat/fnmatch.c

383

for (matchptr = pattern, matchlen = 0; 1; ++matchlen) {

crypto/openssh/openbsd-compat/fnmatch.c

440

while (*pattern && (string < strendseg)) {

crypto/openssh/openbsd-compat/fnmatch.c

442

if (*pattern == '*')

crypto/openssh/openbsd-compat/fnmatch.c

446

(*pattern == '/') || (escape &&

crypto/openssh/openbsd-compat/fnmatch.c

447

(*pattern == '\\') && (pattern[1] == '/'))))

crypto/openssh/openbsd-compat/fnmatch.c

455

if (!fnmatch_ch(&pattern, &string, flags))

crypto/openssh/openbsd-compat/fnmatch.c

470

pattern = mismatch;

crypto/openssh/openbsd-compat/fnmatch.c

480

if (*pattern && !(slash && ((*pattern == '/') ||

crypto/openssh/openbsd-compat/fnmatch.c

481

(escape && (*pattern == '\\') && (pattern[1] == '/')))))

crypto/openssh/openbsd-compat/fnmatch.c

484

if (leading_dir && !*pattern && *string == '/')

crypto/openssh/openbsd-compat/fnmatch.c

489

if (!*string && !*pattern)

crypto/openssh/openbsd-compat/glob.c

180

glob(const char *pattern, int flags, int (*errfunc)(const char *, int),

crypto/openssh/openbsd-compat/glob.c

188

patnext = (u_char *) pattern;

crypto/openssh/openbsd-compat/glob.c

200

if (strnlen(pattern, PATH_MAX) == PATH_MAX)

crypto/openssh/openbsd-compat/glob.c

238

globexp1(const Char *pattern, glob_t *pglob, struct glob_lim *limitp)

crypto/openssh/openbsd-compat/glob.c

240

const Char* ptr = pattern;

crypto/openssh/openbsd-compat/glob.c

243

if (pattern[0] == LBRACE && pattern[1] == RBRACE && pattern[2] == EOS)

crypto/openssh/openbsd-compat/glob.c

244

return glob0(pattern, pglob, limitp);

crypto/openssh/openbsd-compat/glob.c

247

return globexp2(ptr, pattern, pglob, limitp);

crypto/openssh/openbsd-compat/glob.c

249

return glob0(pattern, pglob, limitp);

crypto/openssh/openbsd-compat/glob.c

259

globexp2(const Char *ptr, const Char *pattern, glob_t *pglob,

crypto/openssh/openbsd-compat/glob.c

268

for (lm = patbuf, pm = pattern; pm != ptr; *lm++ = *pm++)

crypto/openssh/openbsd-compat/glob.c

364

globtilde(const Char *pattern, Char *patbuf, size_t patbuf_len, glob_t *pglob)

crypto/openssh/openbsd-compat/glob.c

371

if (*pattern != TILDE || !(pglob->gl_flags & GLOB_TILDE))

crypto/openssh/openbsd-compat/glob.c

372

return pattern;

crypto/openssh/openbsd-compat/glob.c

376

for (p = pattern + 1, h = (char *) patbuf;

crypto/openssh/openbsd-compat/glob.c

397

return pattern;

crypto/openssh/openbsd-compat/glob.c

406

return pattern;

crypto/openssh/openbsd-compat/glob.c

441

const Char *pattern = *patternp + 1;

crypto/openssh/openbsd-compat/glob.c

447

if ((colon = g_strchr(pattern, ':')) == NULL || colon[1] != ']')

crypto/openssh/openbsd-compat/glob.c

450

len = (size_t)(colon - pattern);

crypto/openssh/openbsd-compat/glob.c

452

if (!g_strncmp(pattern, cc->name, len) && cc->name[len] == '\0')

crypto/openssh/openbsd-compat/glob.c

473

glob0(const Char *pattern, glob_t *pglob, struct glob_lim *limitp)

crypto/openssh/openbsd-compat/glob.c

480

qpatnext = globtilde(pattern, patbuf, PATH_MAX, pglob);

crypto/openssh/openbsd-compat/glob.c

563

return(globextend(pattern, pglob, limitp, NULL));

crypto/openssh/openbsd-compat/glob.c

612

glob1(Char *pattern, Char *pattern_last, glob_t *pglob, struct glob_lim *limitp)

crypto/openssh/openbsd-compat/glob.c

617

if (*pattern == EOS)

crypto/openssh/openbsd-compat/glob.c

621

pattern, pattern_last, pglob, limitp));

crypto/openssh/openbsd-compat/glob.c

631

Char *pattern, Char *pattern_last, glob_t *pglob, struct glob_lim *limitp)

crypto/openssh/openbsd-compat/glob.c

642

if (*pattern == EOS) { /* End of pattern? */

crypto/openssh/openbsd-compat/glob.c

671

p = pattern;

crypto/openssh/openbsd-compat/glob.c

682

pattern = p;

crypto/openssh/openbsd-compat/glob.c

683

while (*pattern == SEP) {

crypto/openssh/openbsd-compat/glob.c

686

*pathend++ = *pattern++;

crypto/openssh/openbsd-compat/glob.c

691

pathend_last, pattern, p, pattern_last,

crypto/openssh/openbsd-compat/glob.c

699

Char *pattern, Char *restpattern, Char *restpattern_last, glob_t *pglob,

crypto/openssh/openbsd-compat/glob.c

753

if (dp->d_name[0] == DOT && *pattern != DOT)

crypto/openssh/openbsd-compat/glob.c

765

if (!match(pathend, pattern, restpattern)) {

crypto/openssh/regress/unittests/match/tests.c

114

char pattern[PATTERN_LEN];

crypto/openssh/regress/unittests/match/tests.c

118

for (len = 0; len < sizeof(pattern); len++) {

crypto/openssh/regress/unittests/match/tests.c

123

strlen(pattern_alphabet), pattern, len);

crypto/openssh/regress/unittests/match/tests.c

124

actual = match_pattern(input, pattern);

crypto/openssh/regress/unittests/match/tests.c

125

expected = match_pattern_original(input, pattern);

crypto/openssh/regress/unittests/match/tests.c

127

input, pattern);

crypto/openssh/regress/unittests/match/tests.c

22

match_pattern_original(const char *s, const char *pattern)

crypto/openssh/regress/unittests/match/tests.c

26

if (!*pattern)

crypto/openssh/regress/unittests/match/tests.c

29

if (*pattern == '*') {

crypto/openssh/regress/unittests/match/tests.c

31

while (*pattern == '*')

crypto/openssh/regress/unittests/match/tests.c

32

pattern++;

crypto/openssh/regress/unittests/match/tests.c

35

if (!*pattern)

crypto/openssh/regress/unittests/match/tests.c

39

if (*pattern != '?' && *pattern != '*') {

crypto/openssh/regress/unittests/match/tests.c

46

if (*s == *pattern &&

crypto/openssh/regress/unittests/match/tests.c

48

pattern + 1))

crypto/openssh/regress/unittests/match/tests.c

58

if (match_pattern_original(s, pattern))

crypto/openssh/regress/unittests/match/tests.c

71

if (*pattern != '?' && *pattern != *s)

crypto/openssh/regress/unittests/match/tests.c

76

pattern++;

crypto/openssh/scp.c

764

find_brace(const char *pattern, int *startp, int *endp)

crypto/openssh/scp.c

771

for (i = 0; i < INT_MAX && *endp < 0 && pattern[i] != '\0'; i++) {

crypto/openssh/scp.c

772

switch (pattern[i]) {

crypto/openssh/scp.c

775

if (pattern[i + 1] != '\0')

crypto/openssh/scp.c

787

if (pattern[i + 1] == '}') {

crypto/openssh/scp.c

819

emit_expansion(const char *pattern, int brace_start, int brace_end,

crypto/openssh/scp.c

826

if ((pattern_len = strlen(pattern)) == 0 || pattern_len >= INT_MAX)

crypto/openssh/scp.c

829

tail_len = strlen(pattern + brace_end + 1);

crypto/openssh/scp.c

836

memcpy(cp, pattern, brace_start);

crypto/openssh/scp.c

841

memcpy(cp + o, pattern + sel_start,

crypto/openssh/scp.c

847

memcpy(cp + o, pattern + brace_end + 1, tail_len);

crypto/openssh/scp.c

868

brace_expand_one(const char *pattern, char ***patternsp, size_t *npatternsp,

crypto/openssh/scp.c

877

if (find_brace(pattern, &brace_start, &brace_end) != 0) {

crypto/openssh/scp.c

885

switch (pattern[i]) {

crypto/openssh/scp.c

907

if (pattern[i] == ',' || i == brace_end - 1) {

crypto/openssh/scp.c

914

if (emit_expansion(pattern, brace_start, brace_end,

crypto/openssh/scp.c

933

brace_expand(const char *pattern, char ***patternsp, size_t *npatternsp)

crypto/openssh/scp.c

943

if ((cp = strdup(pattern)) == NULL)

crypto/openssh/sftp-glob.c

136

sftp_glob(struct sftp_conn *conn, const char *pattern, int flags,

crypto/openssh/sftp-glob.c

153

if ((r = glob(pattern, flags | GLOB_ALTDIRFUNC, errfunc, pglob)) != 0)

crypto/openssl/crypto/x509/v3_utl.c

572

typedef int (*equal_fn)(const unsigned char *pattern, size_t pattern_len,

crypto/openssl/crypto/x509/v3_utl.c

581

const unsigned char *pattern = *p;

crypto/openssl/crypto/x509/v3_utl.c

593

while (pattern_len > subject_len && *pattern) {

crypto/openssl/crypto/x509/v3_utl.c

594

if ((flags & X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS) && *pattern == '.')

crypto/openssl/crypto/x509/v3_utl.c

596

++pattern;

crypto/openssl/crypto/x509/v3_utl.c

602

*p = pattern;

crypto/openssl/crypto/x509/v3_utl.c

608

static int equal_nocase(const unsigned char *pattern, size_t pattern_len,

crypto/openssl/crypto/x509/v3_utl.c

612

skip_prefix(&pattern, &pattern_len, subject_len, flags);

crypto/openssl/crypto/x509/v3_utl.c

616

unsigned char l = *pattern;

crypto/openssl/crypto/x509/v3_utl.c

630

++pattern;

crypto/openssl/crypto/x509/v3_utl.c

638

static int equal_case(const unsigned char *pattern, size_t pattern_len,

crypto/openssl/crypto/x509/v3_utl.c

642

skip_prefix(&pattern, &pattern_len, subject_len, flags);

crypto/openssl/crypto/x509/v3_utl.c

645

return !memcmp(pattern, subject, pattern_len);

crypto/openssl/crypto/x509/v3_utl.c

798

static int equal_wildcard(const unsigned char *pattern, size_t pattern_len,

crypto/openssl/crypto/x509/v3_utl.c

809

star = valid_star(pattern, pattern_len, flags);

crypto/openssl/crypto/x509/v3_utl.c

811

return equal_nocase(pattern, pattern_len,

crypto/openssl/crypto/x509/v3_utl.c

813

return wildcard_match(pattern, star - pattern,

crypto/openssl/crypto/x509/v3_utl.c

814

star + 1, (pattern + pattern_len) - star - 1,

lib/libc/gen/fnmatch.c

125

c = *pattern;

lib/libc/gen/fnmatch.c

128

c = *++pattern;

lib/libc/gen/fnmatch.c

155

bt_pattern = pattern;

lib/libc/gen/fnmatch.c

170

switch (rangematch(pattern, sc, string + sclen, flags,

lib/libc/gen/fnmatch.c

175

pattern = newp;

lib/libc/gen/fnmatch.c

184

pclen = mbrtowc(&pc, pattern, MB_LEN_MAX,

lib/libc/gen/fnmatch.c

189

pattern += pclen;

lib/libc/gen/fnmatch.c

224

pattern = bt_pattern;

lib/libc/gen/fnmatch.c

236

rangematch(const char *pattern, wchar_t test, const char *string, int flags,

lib/libc/gen/fnmatch.c

258

if ((negate = (*pattern == '!' || *pattern == '^')))

lib/libc/gen/fnmatch.c

259

++pattern;

lib/libc/gen/fnmatch.c

270

origpat = pattern;

lib/libc/gen/fnmatch.c

273

if (*pattern == ']' && pattern > origpat) {

lib/libc/gen/fnmatch.c

275

} else if (*pattern == '\0') {

lib/libc/gen/fnmatch.c

277

} else if (*pattern == '/' && (flags & FNM_PATHNAME)) {

lib/libc/gen/fnmatch.c

279

} else if (*pattern == '\\' && !(flags & FNM_NOESCAPE)) {

lib/libc/gen/fnmatch.c

280

pattern++;

lib/libc/gen/fnmatch.c

281

} else if (*pattern == '[' &&

lib/libc/gen/fnmatch.c

282

((special = *(pattern + 1)) == '.' ||

lib/libc/gen/fnmatch.c

284

cp = (pattern += 2);

lib/libc/gen/fnmatch.c

295

COLLATE_STR_LEN, pattern,

lib/libc/gen/fnmatch.c

296

cp - pattern, patmbs);

lib/libc/gen/fnmatch.c

299

pattern = cp + 2;

lib/libc/gen/fnmatch.c

348

ec = __collate_equiv_class(pattern,

lib/libc/gen/fnmatch.c

349

cp - pattern, patmbs);

lib/libc/gen/fnmatch.c

356

pattern = cp + 2;

lib/libc/gen/fnmatch.c

379

if (cp - pattern > CHARCLASS_NAME_MAX)

lib/libc/gen/fnmatch.c

381

strlcpy(name, pattern, cp - pattern + 1);

lib/libc/gen/fnmatch.c

382

pattern = cp + 2;

lib/libc/gen/fnmatch.c

393

pclen = mbrtowc(&c, pattern, MB_LEN_MAX, patmbs);

lib/libc/gen/fnmatch.c

396

pattern += pclen;

lib/libc/gen/fnmatch.c

401

if (*pattern == '-' && *(pattern + 1) != EOS &&

lib/libc/gen/fnmatch.c

402

*(pattern + 1) != ']') {

lib/libc/gen/fnmatch.c

403

if (*++pattern == '\\' && !(flags & FNM_NOESCAPE))

lib/libc/gen/fnmatch.c

404

if (*pattern != EOS)

lib/libc/gen/fnmatch.c

405

pattern++;

lib/libc/gen/fnmatch.c

406

pclen = mbrtowc(&c2, pattern, MB_LEN_MAX, patmbs);

lib/libc/gen/fnmatch.c

409

pattern += pclen;

lib/libc/gen/fnmatch.c

413

if ((c2 == '[' && (special = *pattern) == '.') ||

lib/libc/gen/fnmatch.c

422

cp = ++pattern;

lib/libc/gen/fnmatch.c

431

COLLATE_STR_LEN, pattern,

lib/libc/gen/fnmatch.c

432

cp - pattern, patmbs);

lib/libc/gen/fnmatch.c

440

pattern = cp + 2;

lib/libc/gen/fnmatch.c

463

while (*pattern != ']') {

lib/libc/gen/fnmatch.c

464

if (*pattern == 0)

lib/libc/gen/fnmatch.c

466

if (*pattern == special) {

lib/libc/gen/fnmatch.c

467

if (*++pattern == ']') {

lib/libc/gen/fnmatch.c

469

pattern++;

lib/libc/gen/fnmatch.c

473

if (!special && *pattern == '[') {

lib/libc/gen/fnmatch.c

474

special = *++pattern;

lib/libc/gen/fnmatch.c

478

pattern++;

lib/libc/gen/fnmatch.c

481

pclen = mbrtowc(&c, pattern, MB_LEN_MAX, patmbs);

lib/libc/gen/fnmatch.c

484

pattern += pclen;

lib/libc/gen/fnmatch.c

487

*newp = (char *)++pattern;

lib/libc/gen/fnmatch.c

76

fnmatch(const char *pattern, const char *string, int flags)

lib/libc/gen/fnmatch.c

80

return (fnmatch1(pattern, string, string, flags, initial, initial));

lib/libc/gen/fnmatch.c

84

fnmatch1(const char *pattern, const char *string, const char *stringstart,

lib/libc/gen/fnmatch.c

96

pclen = mbrtowc(&pc, pattern, MB_LEN_MAX, &patmbs);

lib/libc/gen/fnmatch.c

99

pattern += pclen;

lib/libc/gen/glob-compat11.c

151

freebsd11_glob(const char * __restrict pattern, int flags,

lib/libc/gen/glob-compat11.c

162

patnext = pattern;

lib/libc/gen/glob-compat11.c

186

return (err_nomatch(pglob, &limit, pattern));

lib/libc/gen/glob-compat11.c

208

return (err_nomatch(pglob, &limit, pattern));

lib/libc/gen/glob-compat11.c

218

return (err_nomatch(pglob, &limit, pattern));

lib/libc/gen/glob-compat11.c

222

return (globexp0(patbuf, pglob, &limit, pattern));

lib/libc/gen/glob-compat11.c

224

return (glob0(patbuf, pglob, &limit, pattern));

lib/libc/gen/glob-compat11.c

228

globexp0(const Char *pattern, glob11_t *pglob, struct glob_limit *limit,

lib/libc/gen/glob-compat11.c

234

if (pattern[0] == LBRACE && pattern[1] == RBRACE && pattern[2] == EOS) {

lib/libc/gen/glob-compat11.c

240

return (glob0(pattern, pglob, limit, origpat));

lib/libc/gen/glob-compat11.c

245

if ((rv = globexp1(pattern, pglob, limit)) != 0)

lib/libc/gen/glob-compat11.c

257

globexp1(const Char *pattern, glob11_t *pglob, struct glob_limit *limit)

lib/libc/gen/glob-compat11.c

261

if ((ptr = g_strchr(pattern, LBRACE)) != NULL) {

lib/libc/gen/glob-compat11.c

267

return (globexp2(ptr, pattern, pglob, limit));

lib/libc/gen/glob-compat11.c

270

return (glob0(pattern, pglob, limit, NULL));

lib/libc/gen/glob-compat11.c

280

globexp2(const Char *ptr, const Char *pattern, glob11_t *pglob,

lib/libc/gen/glob-compat11.c

289

for (lm = patbuf, pm = pattern; pm != ptr; *lm++ = *pm++)

lib/libc/gen/glob-compat11.c

318

return (glob0(pattern, pglob, limit, NULL));

lib/libc/gen/glob-compat11.c

384

globtilde(const Char *pattern, Char *patbuf, size_t patbuf_len, glob11_t *pglob)

lib/libc/gen/glob-compat11.c

397

if (*pattern != TILDE || !(pglob->gl_flags & GLOB_TILDE))

lib/libc/gen/glob-compat11.c

398

return (pattern);

lib/libc/gen/glob-compat11.c

404

for (p = pattern + 1, b = patbuf;

lib/libc/gen/glob-compat11.c

426

return (pattern);

lib/libc/gen/glob-compat11.c

436

return (pattern);

lib/libc/gen/glob-compat11.c

495

glob0(const Char *pattern, glob11_t *pglob, struct glob_limit *limit,

lib/libc/gen/glob-compat11.c

502

qpatnext = globtilde(pattern, patbuf, MAXPATHLEN, pglob);

lib/libc/gen/glob-compat11.c

591

glob1(Char *pattern, glob11_t *pglob, struct glob_limit *limit)

lib/libc/gen/glob-compat11.c

596

if (*pattern == EOS)

lib/libc/gen/glob-compat11.c

599

pattern, pglob, limit));

lib/libc/gen/glob-compat11.c

608

glob2(Char *pathbuf, Char *pathend, Char *pathend_last, Char *pattern,

lib/libc/gen/glob-compat11.c

620

if (*pattern == EOS) { /* End of pattern? */

lib/libc/gen/glob-compat11.c

649

p = pattern;

lib/libc/gen/glob-compat11.c

662

pattern = p;

lib/libc/gen/glob-compat11.c

663

while (UNPROT(*pattern) == SEP) {

lib/libc/gen/glob-compat11.c

668

*pathend++ = *pattern++;

lib/libc/gen/glob-compat11.c

671

return (glob3(pathbuf, pathend, pathend_last, pattern,

lib/libc/gen/glob-compat11.c

679

Char *pattern, Char *restpattern,

lib/libc/gen/glob-compat11.c

737

if (dp->d_name[0] == '.' && UNPROT(*pattern) != DOT) {

lib/libc/gen/glob-compat11.c

764

if (too_long || !match(pathend, pattern, restpattern)) {

lib/libc/gen/glob.c

186

__glob(const char *pattern, glob_t *pglob)

lib/libc/gen/glob.c

196

patnext = pattern;

lib/libc/gen/glob.c

218

return (err_nomatch(pglob, &limit, pattern));

lib/libc/gen/glob.c

240

return (err_nomatch(pglob, &limit, pattern));

lib/libc/gen/glob.c

250

return (err_nomatch(pglob, &limit, pattern));

lib/libc/gen/glob.c

254

return (globexp0(patbuf, pglob, &limit, pattern));

lib/libc/gen/glob.c

256

return (glob0(patbuf, pglob, &limit, pattern));

lib/libc/gen/glob.c

260

glob(const char * __restrict pattern, int flags,

lib/libc/gen/glob.c

267

rv = __glob(pattern, pglob);

lib/libc/gen/glob.c

274

glob_b(const char * __restrict pattern, int flags,

lib/libc/gen/glob.c

282

rv = __glob(pattern, pglob);

lib/libc/gen/glob.c

289

globexp0(const Char *pattern, glob_t *pglob, struct glob_limit *limit,

lib/libc/gen/glob.c

296

if (pattern[0] == LBRACE && pattern[1] == RBRACE && pattern[2] == EOS) {

lib/libc/gen/glob.c

302

return (glob0(pattern, pglob, limit, origpat));

lib/libc/gen/glob.c

307

if ((rv = globexp1(pattern, pglob, limit)) != 0)

lib/libc/gen/glob.c

319

globexp1(const Char *pattern, glob_t *pglob, struct glob_limit *limit)

lib/libc/gen/glob.c

323

if ((ptr = g_strchr(pattern, LBRACE)) != NULL) {

lib/libc/gen/glob.c

329

return (globexp2(ptr, pattern, pglob, limit));

lib/libc/gen/glob.c

332

return (glob0(pattern, pglob, limit, NULL));

lib/libc/gen/glob.c

342

globexp2(const Char *ptr, const Char *pattern, glob_t *pglob,

lib/libc/gen/glob.c

351

for (lm = patbuf, pm = pattern; pm != ptr; *lm++ = *pm++)

lib/libc/gen/glob.c

380

return (glob0(pattern, pglob, limit, NULL));

lib/libc/gen/glob.c

446

globtilde(const Char *pattern, Char *patbuf, size_t patbuf_len, glob_t *pglob)

lib/libc/gen/glob.c

459

if (*pattern != TILDE || !(pglob->gl_flags & GLOB_TILDE))

lib/libc/gen/glob.c

460

return (pattern);

lib/libc/gen/glob.c

466

for (p = pattern + 1, b = patbuf;

lib/libc/gen/glob.c

488

return (pattern);

lib/libc/gen/glob.c

498

return (pattern);

lib/libc/gen/glob.c

557

glob0(const Char *pattern, glob_t *pglob, struct glob_limit *limit,

lib/libc/gen/glob.c

564

qpatnext = globtilde(pattern, patbuf, MAXPATHLEN, pglob);

lib/libc/gen/glob.c

654

glob1(Char *pattern, glob_t *pglob, struct glob_limit *limit)

lib/libc/gen/glob.c

659

if (*pattern == EOS)

lib/libc/gen/glob.c

662

pattern, pglob, limit));

lib/libc/gen/glob.c

671

glob2(Char *pathbuf, Char *pathend, Char *pathend_last, Char *pattern,

lib/libc/gen/glob.c

683

if (*pattern == EOS) { /* End of pattern? */

lib/libc/gen/glob.c

712

p = pattern;

lib/libc/gen/glob.c

725

pattern = p;

lib/libc/gen/glob.c

726

while (UNPROT(*pattern) == SEP) {

lib/libc/gen/glob.c

731

*pathend++ = *pattern++;

lib/libc/gen/glob.c

734

return (glob3(pathbuf, pathend, pathend_last, pattern,

lib/libc/gen/glob.c

742

Char *pattern, Char *restpattern,

lib/libc/gen/glob.c

799

if (dp->d_name[0] == '.' && UNPROT(*pattern) != DOT) {

lib/libc/gen/glob.c

826

if (too_long || !match(pathend, pattern, restpattern)) {

lib/libc/regex/regcomp.c

204

const char * __restrict pattern,

lib/libc/regex/regcomp.c

224

if (preg->re_endp < pattern)

lib/libc/regex/regcomp.c

226

len = preg->re_endp - pattern;

lib/libc/regex/regcomp.c

228

len = strlen(pattern);

lib/libc/regex/regcomp.c

260

p->next = pattern; /* convenience; we do not modify it */

lib/libc/regex/regcomp.c

359

const char * __restrict pattern,

lib/libc/regex/regcomp.c

363

return (regcomp_internal(preg, pattern, cflags, 0));

lib/libc/regex/regcomp.c

372

const char * __restrict pattern,

lib/libc/regex/regcomp.c

376

return (regcomp_internal(preg, pattern, cflags, PFLAG_LEGACY_ESC));

lib/libc/tests/gen/fnmatch_test.c

104

if ((t->string[0] != '.' || t->pattern[0] == '.' ||

lib/libc/tests/gen/fnmatch_test.c

108

result = fnmatch(t->pattern, t->string, flags);

lib/libc/tests/gen/fnmatch_test.c

117

result = fnmatch(t->pattern, t->string, flags);

lib/libc/tests/gen/fnmatch_test.c

122

if ((((t->string[0] != '.' || t->pattern[0] == '.') &&

lib/libc/tests/gen/fnmatch_test.c

127

result = fnmatch(t->pattern, t->string, flags);

lib/libc/tests/gen/fnmatch_test.c

132

if ((((t->string[0] != '.' || t->pattern[0] == '.') &&

lib/libc/tests/gen/fnmatch_test.c

137

result = fnmatch(t->pattern, t->string, flags);

lib/libc/tests/gen/fnmatch_test.c

145

result = fnmatch(t->pattern, t->string, flags);

lib/libc/tests/gen/fnmatch_test.c

152

result = fnmatch(t->pattern, t->string, flags);

lib/libc/tests/gen/fnmatch_test.c

157

if (strchr(t->pattern, '\\') == NULL &&

lib/libc/tests/gen/fnmatch_test.c

161

result = fnmatch(t->pattern, t->string, flags);

lib/libc/tests/gen/fnmatch_test.c

171

t->pattern, t->string, flags_to_string(flags), result);

lib/libc/tests/gen/fnmatch_test.c

174

t->pattern, t->string, flags_to_string(flags),

lib/libc/tests/gen/fnmatch_test.c

83

result = fnmatch(t->pattern, t->string, flags);

lib/libc/tests/gen/fnmatch_test.c

86

if (strchr(t->pattern, '\\') == NULL &&

lib/libc/tests/gen/fnmatch_test.c

89

result = fnmatch(t->pattern, t->string, flags);

lib/libc/tests/gen/fnmatch_test.c

94

if (strchr(t->pattern, '\\') != NULL &&

lib/libc/tests/gen/fnmatch_test.c

99

result = fnmatch(t->pattern, t->string, flags);

lib/libc/tests/gen/fnmatch_testcases.h

30

const char *pattern;

lib/libc/tests/gen/glob2_test.c

53

char pattern[1000], *p;

lib/libc/tests/gen/glob2_test.c

69

p = pattern;

lib/libc/tests/gen/glob2_test.c

80

rc = glob(pattern, 0, 0, &g);

lib/libc/tests/gen/glob2_test.c

89

"A bogus match occurred: '%s' ~ '%s'", pattern,

lib/libc/tests/gen/test-fnmatch.c

57

if (strchr(t->pattern, '\'') != NULL ||

lib/libc/tests/gen/test-fnmatch.c

60

if (t->flags == 0 && strcmp(t->pattern, "\\") == 0)

lib/libc/tests/gen/test-fnmatch.c

65

t->pattern, t->string);

lib/libc/tests/gen/test-fnmatch.c

67

(t->flags == 0 && strchr(t->pattern, '\\') == NULL)))

lib/libc/tests/gen/test-fnmatch.c

70

t->pattern, t->string);

lib/libc/tests/sys/sendfile_test.c

693

char *pattern;

lib/libc/tests/sys/sendfile_test.c

715

rc = asprintf(&pattern, "%s%s%s",

lib/libc/tests/sys/sendfile_test.c

721

atf_utils_create_file(SOURCE_FILE ".full", "%s", pattern);

lib/libc/tests/sys/sendfile_test.c

734

strlen(pattern));

lib/libc/tests/sys/sendfile_test.c

750

free(pattern);

lib/libc/tests/sys/sendfile_test.c

751

pattern = NULL;

lib/libcam/camlib.c

319

match_pat = &ccb.cdm.patterns[0].pattern.periph_pattern;

libexec/flua/modules/lposix.c

270

const char *pattern, *string;

libexec/flua/modules/lposix.c

274

pattern = luaL_checkstring(L, 1);

libexec/flua/modules/lposix.c

278

lua_pushinteger(L, fnmatch(pattern, string, flags));

libexec/getty/subr.c

464

edithost(const char *pattern)

libexec/getty/subr.c

470

if (pattern == NULL || *pattern == '\0')

libexec/getty/subr.c

472

if (regcomp(&regex, pattern, REG_EXTENDED) != 0)

sbin/camcontrol/camcontrol.c

3769

matchccb->cdm.patterns[0].pattern.bus_pattern.flags = BUS_MATCH_ANY;

sbin/camcontrol/camcontrol.c

6959

const char *pattern = NULL;

sbin/camcontrol/camcontrol.c

7014

pattern = optarg;

sbin/camcontrol/camcontrol.c

7048

if (pattern == NULL) {

sbin/camcontrol/camcontrol.c

7053

fd = open(pattern, O_RDONLY);

sbin/camcontrol/camcontrol.c

7055

warn("cannot open pattern file %s", pattern);

sbin/camcontrol/camcontrol.c

7060

warn("cannot stat pattern file %s", pattern);

sbin/camcontrol/camcontrol.c

7105

else if (pattern != NULL)

sbin/camcontrol/camcontrol.c

8926

patterns[0].pattern.device_pattern.flags = DEV_MATCH_PATH;

sbin/camcontrol/camcontrol.c

8927

patterns[0].pattern.device_pattern.path_id = devlist->path_id;

sbin/camcontrol/camcontrol.c

8929

patterns[1].pattern.periph_pattern.flags = PERIPH_MATCH_PATH;

sbin/camcontrol/camcontrol.c

8930

patterns[1].pattern.periph_pattern.path_id = devlist->path_id;

sbin/camcontrol/fwdownload.c

165

const char *pattern;

sbin/camcontrol/fwdownload.c

308

for (vp = vendors_list; vp->pattern != NULL; vp++) {

sbin/camcontrol/fwdownload.c

316

for (vp = vendors_list; vp->pattern != NULL; vp++) {

sbin/camcontrol/fwdownload.c

318

(const u_char *)vp->pattern, strlen(vendor))) {

sbin/recoverdisk/recoverdisk.c

413

fill_buf(char *buf, int64_t len, const char *pattern)

sbin/recoverdisk/recoverdisk.c

415

int64_t sz = strlen(pattern);

sbin/recoverdisk/recoverdisk.c

419

memcpy(buf + i, pattern, MIN(len - i, sz));

sys/arm/arm/disassem.c

106

u_int pattern;

sys/arm/arm/disassem.c

304

if ((insn & i_ptr->mask) == i_ptr->pattern) {

sys/arm64/arm64/disassem.c

136

uint32_t pattern;

sys/arm64/arm64/disassem.c

372

tab->pattern = val;

sys/arm64/arm64/disassem.c

382

tab->pattern = 0xffffffff;

sys/arm64/arm64/disassem.c

520

((insn & i_ptr->mask) == i_ptr->pattern)) {

sys/cam/cam.c

210

cam_strmatch(const uint8_t *str, const uint8_t *pattern, int str_len)

sys/cam/cam.c

213

while (*pattern != '\0' && str_len > 0) {

sys/cam/cam.c

214

if (*pattern == '*') {

sys/cam/cam.c

215

pattern++;

sys/cam/cam.c

216

if (*pattern == '\0')

sys/cam/cam.c

219

if (cam_strmatch(str, pattern, str_len) == 0)

sys/cam/cam.c

225

} else if (*pattern == '[') {

sys/cam/cam.c

233

pattern++;

sys/cam/cam.c

234

if ((negate_range = (*pattern == '^')) != 0)

sys/cam/cam.c

235

pattern++;

sys/cam/cam.c

236

while ((*pattern != ']') && *pattern != '\0') {

sys/cam/cam.c

237

if (*pattern == '-') {

sys/cam/cam.c

238

if (pattern[1] == '\0') /* Bad pattern */

sys/cam/cam.c

240

if (sc >= pc && sc <= pattern[1])

sys/cam/cam.c

242

pattern++;

sys/cam/cam.c

243

} else if (*pattern == sc)

sys/cam/cam.c

245

pc = *pattern;

sys/cam/cam.c

246

pattern++;

sys/cam/cam.c

250

pattern++;

sys/cam/cam.c

251

} else if (*pattern == '?') {

sys/cam/cam.c

256

pattern++;

sys/cam/cam.c

260

if (*str != *pattern)

sys/cam/cam.c

262

pattern++;

sys/cam/cam.c

269

while (*pattern == '*')

sys/cam/cam.c

270

pattern++;

sys/cam/cam.c

272

if ( *pattern != '\0') {

sys/cam/cam.h

411

int cam_strmatch(const uint8_t *str, const uint8_t *pattern, int str_len);

sys/cam/cam_ccb.h

498

union match_pattern pattern;

sys/cam/cam_compat.c

454

p->pattern.bus_pattern.flags == 0x00f)

sys/cam/cam_compat.c

455

p->pattern.bus_pattern.flags = BUS_MATCH_ANY;

sys/cam/cam_compat.c

457

p->pattern.device_pattern.flags == 0x00f)

sys/cam/cam_compat.c

458

p->pattern.device_pattern.flags = DEV_MATCH_ANY;

sys/cam/cam_compat.c

460

p->pattern.periph_pattern.flags == 0x01f)

sys/cam/cam_compat.c

461

p->pattern.periph_pattern.flags = PERIPH_MATCH_ANY;

sys/cam/cam_xpt.c

1320

struct device_match_pattern *dp = &patterns[i].pattern.device_pattern;

sys/cam/cam_xpt.c

1321

struct periph_match_pattern *pp = &patterns[i].pattern.periph_pattern;

sys/cam/cam_xpt.c

1344

cur_pattern = &patterns[i].pattern.bus_pattern;

sys/cam/cam_xpt.c

1421

struct periph_match_pattern *pp = &patterns[i].pattern.periph_pattern;

sys/cam/cam_xpt.c

1442

cur_pattern = &patterns[i].pattern.device_pattern;

sys/cam/cam_xpt.c

1550

cur_pattern = &patterns[i].pattern.periph_pattern;

sys/cam/ctl/ctl.c

12092

if (entry->pattern & CTL_LUN_PAT_WRITE) {

sys/cam/ctl/ctl.c

13140

ctl_lun_error_pattern filtered_pattern, pattern;

sys/cam/ctl/ctl.c

13142

pattern = desc->error_pattern;

sys/cam/ctl/ctl.c

13149

if (pattern & CTL_LUN_PAT_CMD)

sys/cam/ctl/ctl.c

13152

if ((pattern & CTL_LUN_PAT_MASK) == CTL_LUN_PAT_ANY)

sys/cam/ctl/ctl.c

13157

filtered_pattern = entry->pattern & pattern;

sys/cam/ctl/ctl.c

13168

(pattern & ~CTL_LUN_PAT_MASK))

sys/cam/ctl/ctl.c

13208

ctl_lun_error_pattern pattern;

sys/cam/ctl/ctl.c

13213

pattern = ctl_cmd_pattern_match(&io->scsiio, desc);

sys/cam/ctl/ctl.c

13214

if ((pattern & CTL_LUN_PAT_MASK) == CTL_LUN_PAT_NONE)

sys/cam/ctl/ctl_private.h

137

ctl_lun_error_pattern pattern;

sys/cam/scsi/scsi_enc_ses.c

887

device_pattern = &match_pattern.pattern.device_pattern;

sys/compat/linuxkpi/common/include/net/cfg80211.h

1608

const uint8_t *data, size_t len, uint8_t *pattern, size_t plen)

sys/compat/linuxkpi/common/include/net/cfg80211.h

1622

if (pattern == NULL)

sys/compat/linuxkpi/common/include/net/cfg80211.h

1625

memcmp(elem->data, pattern, plen) == 0)

sys/compat/linuxkpi/common/include/net/cfg80211.h

1664

uint8_t pattern[4] = { oui << 16, oui << 8, oui, oui_type };

sys/compat/linuxkpi/common/include/net/cfg80211.h

1669

data, len, pattern, plen);

sys/compat/linuxkpi/common/include/net/cfg80211.h

925

uint8_t *pattern;

sys/dev/hid/ietp.c

458

uint8_t pattern;

sys/dev/hid/ietp.c

477

pattern = (resp[0] == 0xFF && resp[1] == 0xFF) ? 0 : resp[1];

sys/dev/hid/ietp.c

478

if (pattern >= 0x02)

sys/dev/hid/ietp.c

512

uint8_t pattern;

sys/dev/hid/ietp.c

526

pattern = buf == 0xFFFF ? 0 : buf8[1];

sys/dev/hid/ietp.c

527

sc->hi_precision = pattern >= 0x02;

sys/dev/hid/ietp.c

529

reg = pattern >= 0x01 ? IETP_IC_TYPE : IETP_OSM_VERSION;

sys/dev/hid/ietp.c

534

sc->ic_type = pattern >= 0x01 ? be16toh(buf) : buf8[1];

sys/dev/ntb/test/ntb_tool.c

453

uint64_t *pattern, bool *s_pflag)

sys/dev/ntb/test/ntb_tool.c

474

*pattern = val1;

sys/dev/ntb/test/ntb_tool.c

485

*pattern = val2;

sys/dev/ntb/test/ntb_tool.c

494

*pattern = val3;

sys/dev/ntb/test/ntb_tool.c

579

uint64_t pattern = 0;

sys/dev/ntb/test/ntb_tool.c

591

rc = parse_mw_buf(ubuf, &cmd, buf_offset, buf_size, &pattern, &s_pflag);

sys/dev/ntb/test/ntb_tool.c

621

memset(data_buf, pattern, data_buf_size);

sys/dev/oce/oce_hw.h

2021

uint64_t pattern;

sys/dev/oce/oce_if.h

1041

uint64_t pattern);

sys/dev/oce/oce_mbox.c

1400

uint64_t pattern)

sys/dev/oce/oce_mbox.c

1417

fwcmd->params.req.pattern = pattern;

sys/dev/pms/RefTisa/sallsdk/api/sa.h

1982

bit32 pattern;

sys/dev/pms/RefTisa/sallsdk/spc/saioctlcmd.c

3816

SA_DBG1(("saPCIeDiagExecute, diag->pattern 0x%X\n",diag->pattern ));

sys/dev/pms/RefTisa/sallsdk/spc/saioctlcmd.c

3879

OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaPCIeDiagExecuteCmd_t, pattern), diag->pattern);

sys/dev/pms/RefTisa/sallsdk/spc/saioctlcmd.c

3892

OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsa_SPC_PCIDiagExecuteCmd_t, pattern), diag->pattern);

sys/dev/pms/RefTisa/sallsdk/spc/sampidefs.h

903

bit32 pattern; /* 13 */

sys/dev/pms/RefTisa/sallsdk/spc/sampidefs.h

923

bit32 pattern;

sys/dev/qlnx/qlnxe/ecore_hsi_init_tool.h

174

struct init_array_pattern_hdr pattern /* pattern init array header */;

sys/dev/qlxgb/qla_glbl.h

99

void *buf, uint32_t pattern);

sys/dev/qlxgb/qla_ioctl.c

121

wrf->buffer, wrf->pattern)))

sys/dev/qlxgb/qla_ioctl.h

57

uint32_t pattern;

sys/dev/qlxgb/qla_misc.c

1006

uint32_t pattern)

sys/dev/qlxgb/qla_misc.c

1017

rval = qla_flash_write_pattern(ha, off, size, pattern);

sys/dev/qlxgb/qla_misc.c

931

uint32_t pattern)

sys/dev/qlxgb/qla_misc.c

946

if (qla_flash_write(ha, start, pattern)) {

sys/dev/qlxgbe/ql_ioctl.h

57

uint32_t pattern;

sys/dev/sfxge/common/siena_nic.c

698

__in efx_pattern_type_t pattern,

sys/dev/sfxge/common/siena_nic.c

708

EFSYS_ASSERT(pattern < EFX_PATTERN_NTYPES);

sys/dev/sfxge/common/siena_nic.c

709

func = __efx_sram_pattern_fns[pattern];

sys/dev/syscons/star/star_saver.c

58

static u_char pattern[] = {"...........++++*** "};

sys/dev/syscons/star/star_saver.c

86

sc->scr_map[pattern[stars[cell][1]]],

sys/dev/syscons/star/star_saver.c

88

if ((stars[cell][1]+=(random()%4)) >= sizeof(pattern)-1) {

sys/dev/usb/gadget/g_audio.c

119

SYSCTL_STRING(_hw_usb_g_audio, OID_AUTO, pattern, CTLFLAG_RW,

sys/dev/usb/gadget/g_modem.c

115

SYSCTL_STRING(_hw_usb_g_modem, OID_AUTO, pattern, CTLFLAG_RW,

sys/dev/virtio/gpu/virtio_gpu.c

169

const uint8_t *pattern, const uint8_t *mask,

sys/dev/virtio/gpu/virtio_gpu.c

179

vt_fb_bitblt_bitmap(vd, vw, pattern, mask, width, height, x, y, fg, bg);

sys/dev/vt/hw/fb/vt_fb.c

280

const uint8_t *pattern, const uint8_t *mask,

sys/dev/vt/hw/fb/vt_fb.c

320

cc = pattern[byte] & bit ? fgc : bgc;

sys/dev/vt/hw/fb/vt_fb.c

397

const uint8_t *pattern;

sys/dev/vt/hw/fb/vt_fb.c

411

pattern = vtfont_lookup(vf, c);

sys/dev/vt/hw/fb/vt_fb.c

425

pattern, NULL, vf->vf_width, vf->vf_height,

sys/dev/vt/hw/ofwfb/ofwfb.c

134

const uint8_t *pattern, const uint8_t *mask,

sys/dev/vt/hw/ofwfb/ofwfb.c

179

b = *pattern++;

sys/dev/vt/hw/ofwfb/ofwfb.c

216

b = *pattern++;

sys/dev/vt/hw/ofwfb/ofwfb.c

265

const uint8_t *pattern;

sys/dev/vt/hw/ofwfb/ofwfb.c

278

pattern = vtfont_lookup(vf, c);

sys/dev/vt/hw/ofwfb/ofwfb.c

283

pattern, NULL, vf->vf_width, vf->vf_height,

sys/dev/vt/hw/vga/vt_vga.c

396

uint8_t *pattern, uint8_t *mask)

sys/dev/vt/hw/vga/vt_vga.c

414

*pattern = src[n];

sys/dev/vt/hw/vga/vt_vga.c

416

*pattern >>= (dst_x - src_x % 8);

sys/dev/vt/hw/vga/vt_vga.c

418

*pattern <<= (src_x % 8 - dst_x);

sys/dev/vt/hw/vga/vt_vga.c

422

*pattern =

sys/dev/vt/hw/vga/vt_vga.c

426

*pattern =

sys/dev/vt/hw/vga/vt_vga.c

441

uint8_t pattern, relevant_bits, mask;

sys/dev/vt/hw/vga/vt_vga.c

447

bytes, src_x, x_count, dst_x, &pattern, &relevant_bits);

sys/dev/vt/hw/vga/vt_vga.c

473

pattern &= mask;

sys/dev/vt/hw/vga/vt_vga.c

478

pattern_2colors[dst_y + i] |= pattern;

sys/dev/vt/hw/vga/vt_vga.c

497

pattern_ncolors[(dst_y + i) * 16 + fg] |= pattern;

sys/dev/vt/hw/vga/vt_vga.c

498

pattern_ncolors[(dst_y + i) * 16 + bg] |= (~pattern & mask);

sys/dev/vt/hw/vga/vt_vga.c

962

const uint8_t *pattern, const uint8_t *mask,

sys/dev/vt/hw/vga/vt_vga.c

988

pattern, mask, width,

sys/dev/vt/vt.h

346

const uint8_t *pattern, const uint8_t *mask,

sys/dev/vt/vt_core.c

1418

const uint8_t *pattern;

sys/dev/vt/vt_core.c

1442

pattern = vtfont_lookup(vf, c);

sys/dev/vt/vt_core.c

1444

pattern, NULL, vf->vf_width, vf->vf_height,

sys/libkern/fnmatch.c

104

if (!fnmatch(pattern, string, flags & ~FNM_PERIOD))

sys/libkern/fnmatch.c

121

switch (rangematch(pattern, *string, flags, &newp)) {

sys/libkern/fnmatch.c

125

pattern = newp;

sys/libkern/fnmatch.c

134

if ((c = *pattern++) == EOS) {

sys/libkern/fnmatch.c

136

--pattern;

sys/libkern/fnmatch.c

157

rangematch(const char *pattern, char test, int flags, char **newp)

sys/libkern/fnmatch.c

169

if ( (negate = (*pattern == '!' || *pattern == '^')) )

sys/libkern/fnmatch.c

170

++pattern;

sys/libkern/fnmatch.c

181

c = *pattern++;

sys/libkern/fnmatch.c

184

c = *pattern++;

sys/libkern/fnmatch.c

194

if (*pattern == '-'

sys/libkern/fnmatch.c

195

&& (c2 = *(pattern+1)) != EOS && c2 != ']') {

sys/libkern/fnmatch.c

196

pattern += 2;

sys/libkern/fnmatch.c

198

c2 = *pattern++;

sys/libkern/fnmatch.c

209

} while ((c = *pattern++) != ']');

sys/libkern/fnmatch.c

211

*newp = (char *)(uintptr_t)pattern;

sys/libkern/fnmatch.c

54

fnmatch(const char *pattern, const char *string, int flags)

sys/libkern/fnmatch.c

61

switch (c = *pattern++) {

sys/libkern/fnmatch.c

78

c = *pattern;

sys/libkern/fnmatch.c

81

c = *++pattern;

tools/tools/usbtest/usbtest.c

196

char pattern[G_AUDIO_MAX_STRLEN] = {"0123456789abcdef"};

tools/tools/usbtest/usbtest.c

226

&pattern, strlen(pattern));

tools/tools/usbtest/usbtest.c

230

"to '%s' (error=%d)\n", pattern, errno);

tools/tools/usbtest/usbtest.c

246

pattern, pattern_interval, throughput);

tools/tools/usbtest/usbtest.c

264

get_string(pattern, sizeof(pattern));

tools/tools/usbtest/usbtest.c

317

char pattern[G_KEYBOARD_MAX_STRLEN] = {"abcdefpattern"};

tools/tools/usbtest/usbtest.c

338

&pattern, strlen(pattern));

tools/tools/usbtest/usbtest.c

342

"to '%s' (error=%d)\n", pattern, errno);

tools/tools/usbtest/usbtest.c

353

pattern, interval);

tools/tools/usbtest/usbtest.c

365

get_string(pattern, sizeof(pattern));

tools/tools/usbtest/usbtest.c

525

char pattern[G_MODEM_MAX_STRLEN] = {"abcdefpattern"};

tools/tools/usbtest/usbtest.c

555

&pattern, strlen(pattern));

tools/tools/usbtest/usbtest.c

559

"to '%s' (error=%d)\n", pattern, errno);

tools/tools/usbtest/usbtest.c

575

pattern, pattern_interval, throughput);

tools/tools/usbtest/usbtest.c

593

get_string(pattern, sizeof(pattern));

usr.bin/diff/diff.c

486

checked_regcomp(char const *pattern, regex_t *comp)

usr.bin/diff/diff.c

491

if (pattern == NULL)

usr.bin/diff/diff.c

494

error = regcomp(comp, pattern, REG_NEWLINE | REG_EXTENDED);

usr.bin/diff/diff.c

497

if (*pattern != '\0')

usr.bin/diff/diff.c

498

errx(2, "%s: %s", pattern, buf);

usr.bin/diff/diff.c

528

char *pattern = NULL;

usr.bin/diff/diff.c

536

while ((len = getline(&pattern, &blen, fp)) >= 0) {

usr.bin/diff/diff.c

537

if ((len > 0) && (pattern[len - 1] == '\n'))

usr.bin/diff/diff.c

538

pattern[len - 1] = '\0';

usr.bin/diff/diff.c

539

push_excludes(pattern);

usr.bin/diff/diff.c

541

pattern = NULL;

usr.bin/diff/diff.c

544

free(pattern);

usr.bin/diff/diff.c

553

push_excludes(char *pattern)

usr.bin/diff/diff.c

558

entry->pattern = pattern;

usr.bin/diff/diff.c

564

push_ignore_pats(char *pattern)

usr.bin/diff/diff.c

569

ignore_pats = xstrdup(pattern);

usr.bin/diff/diff.c

572

len = strlen(ignore_pats) + strlen(pattern) + 2;

usr.bin/diff/diff.c

575

strlcat(ignore_pats, pattern, len);

usr.bin/diff/diff.h

110

char *pattern;

usr.bin/diff/diffdir.c

381

if (fnmatch(excl->pattern, dp->d_name, FNM_PATHNAME) == 0)

usr.bin/find/function.c

1219

char *pattern;

usr.bin/find/function.c

1222

pattern = nextarg(option, argvp);

usr.bin/find/function.c

1224

new->c_data = pattern;

usr.bin/find/function.c

1527

char *pattern;

usr.bin/find/function.c

1535

pattern = nextarg(option, argvp);

usr.bin/find/function.c

1537

if ((errcode = regcomp(pre, pattern,

usr.bin/find/function.c

1542

pattern, errbuf);

usr.bin/grep/grep.c

218

pattern = grep_realloc(pattern, ++pattern_sz *

usr.bin/grep/grep.c

224

pattern[patterns].pat = grep_malloc(len + 1);

usr.bin/grep/grep.c

225

memcpy(pattern[patterns].pat, pat, len);

usr.bin/grep/grep.c

226

pattern[patterns].len = len;

usr.bin/grep/grep.c

227

pattern[patterns].pat[len] = '\0';

usr.bin/grep/grep.c

686

c = regcomp(&r_pattern[i], pattern[i].pat, cflags);

usr.bin/grep/grep.c

74

struct pat *pattern;

usr.bin/grep/grep.h

132

extern struct pat *pattern;

usr.bin/grep/util.c

585

r = litexec(&pattern[i], pc->ln.dat, 1, &pmatch);

usr.bin/login/login_fbtab.c

120

login_protect(const char *table, char *pattern, int mask, uid_t uid, gid_t gid)

usr.bin/login/login_fbtab.c

126

if (glob(pattern, GLOB_NOSORT, NULL, &gl) != 0)

usr.bin/posixmqcontrol/posixmqcontrol.c

348

const char **pattern;

usr.bin/posixmqcontrol/posixmqcontrol.c

373

const char **pattern = option->pattern;

usr.bin/posixmqcontrol/posixmqcontrol.c

375

while (*pattern != NULL && !match) {

usr.bin/posixmqcontrol/posixmqcontrol.c

376

const char *knob = *pattern;

usr.bin/posixmqcontrol/posixmqcontrol.c

380

pattern++;

usr.bin/posixmqcontrol/posixmqcontrol.c

750

.pattern = names_queue,

usr.bin/posixmqcontrol/posixmqcontrol.c

754

.pattern = names_queue,

usr.bin/posixmqcontrol/posixmqcontrol.c

759

.pattern = names_depth,

usr.bin/posixmqcontrol/posixmqcontrol.c

764

.pattern = names_size,

usr.bin/posixmqcontrol/posixmqcontrol.c

769

.pattern = names_block,

usr.bin/posixmqcontrol/posixmqcontrol.c

775

.pattern = names_content,

usr.bin/posixmqcontrol/posixmqcontrol.c

780

.pattern = names_priority,

usr.bin/posixmqcontrol/posixmqcontrol.c

785

.pattern = names_mode,

usr.bin/posixmqcontrol/posixmqcontrol.c

790

.pattern = names_group,

usr.bin/posixmqcontrol/posixmqcontrol.c

795

.pattern = names_user,

usr.bin/primes/pattern.c

436

const size_t pattern_size = (sizeof(pattern)/sizeof(pattern[0]));

usr.bin/primes/pattern.c

49

const char pattern[] = {

usr.bin/primes/primes.c

261

memcpy(table, &pattern[factor], pattern_size-factor);

usr.bin/primes/primes.c

265

memcpy(&table[fact_lim], pattern, pattern_size);

usr.bin/primes/primes.c

268

memcpy(&table[fact_lim], pattern, TABSIZE-fact_lim);

usr.bin/primes/primes.h

67

extern const char pattern[];

usr.sbin/bluetooth/l2ping/l2ping.c

187

memcpy(echo_data + n, pattern, avail);

usr.sbin/bluetooth/l2ping/l2ping.c

55

static char const pattern[] = "1234567890-";

usr.sbin/bluetooth/l2ping/l2ping.c

56

#define PATTERN_SIZE (sizeof(pattern) - 1)

usr.sbin/ctladm/ctladm.c

1049

if ((err_desc.pattern & CTL_LUN_PAT_READWRITE) == 0) {

usr.sbin/ctladm/ctladm.c

898

ctl_lun_error_pattern pattern;

usr.sbin/ctladm/ctladm.c

901

&pattern, &argnum, &subopt);

usr.sbin/ctladm/ctladm.c

902

err_desc.error_pattern |= pattern;

usr.sbin/mptutil/mpt_cam.c

161

p = &ccb.cdm.patterns[0].pattern.periph_pattern;

usr.sbin/mptutil/mpt_cam.c

426

p = &ccb.cdm.patterns[0].pattern.periph_pattern;

usr.sbin/mptutil/mpt_cam.c

87

b = &ccb.cdm.patterns[0].pattern.bus_pattern;