regcomp.c Source File (original) (raw)

39#include <ctype.h>

40#include <limits.h>

41#include <stdint.h>

42#include <stdio.h>

43#include <stdlib.h>

45#include <sys/types.h>

50#include "llvm/Config/config.h"

59 {"alnum", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\

600123456789",

61 ""},

62 {"alpha", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", ""},

63 {"blank", " \t", ""},

64 {"cntrl", "\007\b\t\n\v\f\r\1\2\3\4\5\6\16\17\20\21\22\23\24\

65\25\26\27\30\31\32\33\34\35\36\37\177",

66 ""},

67 {"digit", "0123456789", ""},

68 {"graph", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\

690123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",

70 ""},

71 {"lower", "abcdefghijklmnopqrstuvwxyz", ""},

72 {"print", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\

730123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ",

74 ""},

75 {"punct", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", ""},

76 {"space", "\t\n\v\f\r ", ""},

77 {"upper", "ABCDEFGHIJKLMNOPQRSTUVWXYZ", ""},

78 {"xdigit", "0123456789ABCDEFabcdef", ""},

79 {NULL, 0, ""}};

85} cnames[] = {{"NUL", '\0'},

86 {"SOH", '\001'},

87 {"STX", '\002'},

88 {"ETX", '\003'},

89 {"EOT", '\004'},

90 {"ENQ", '\005'},

91 {"ACK", '\006'},

92 {"BEL", '\007'},

93 {"alert", '\007'},

94 {"BS", '\010'},

95 {"backspace", '\b'},

96 {"HT", '\011'},

97 {"tab", '\t'},

98 {"LF", '\012'},

99 {"newline", '\n'},

100 {"VT", '\013'},

101 {"vertical-tab", '\v'},

102 {"FF", '\014'},

103 {"form-feed", '\f'},

104 {"CR", '\015'},

105 {"carriage-return", '\r'},

106 {"SO", '\016'},

107 {"SI", '\017'},

108 {"DLE", '\020'},

109 {"DC1", '\021'},

110 {"DC2", '\022'},

111 {"DC3", '\023'},

112 {"DC4", '\024'},

113 {"NAK", '\025'},

114 {"SYN", '\026'},

115 {"ETB", '\027'},

116 {"CAN", '\030'},

117 {"EM", '\031'},

118 {"SUB", '\032'},

119 {"ESC", '\033'},

120 {"IS4", '\034'},

121 {"FS", '\034'},

122 {"IS3", '\035'},

123 {"GS", '\035'},

124 {"IS2", '\036'},

125 {"RS", '\036'},

126 {"IS1", '\037'},

127 {"US", '\037'},

128 {"space", ' '},

129 {"exclamation-mark", '!'},

130 {"quotation-mark", '"'},

131 {"number-sign", '#'},

132 {"dollar-sign", '$'},

133 {"percent-sign", '%'},

134 {"ampersand", '&'},

135 {"apostrophe", '\''},

136 {"left-parenthesis", '('},

137 {"right-parenthesis", ')'},

138 {"asterisk", '*'},

139 {"plus-sign", '+'},

140 {"comma", ','},

141 {"hyphen", '-'},

142 {"hyphen-minus", '-'},

143 {"period", '.'},

144 {"full-stop", '.'},

145 {"slash", '/'},

146 {"solidus", '/'},

147 {"zero", '0'},

148 {"one", '1'},

149 {"two", '2'},

150 {"three", '3'},

151 {"four", '4'},

152 {"five", '5'},

153 {"six", '6'},

154 {"seven", '7'},

155 {"eight", '8'},

156 {"nine", '9'},

157 {"colon", ':'},

158 {"semicolon", ';'},

159 {"less-than-sign", '<'},

160 {"equals-sign", '='},

161 {"greater-than-sign", '>'},

162 {"question-mark", '?'},

163 {"commercial-at", '@'},

164 {"left-square-bracket", '['},

165 {"backslash", '\\'},

166 {"reverse-solidus", '\\'},

167 {"right-square-bracket", ']'},

168 {"circumflex", '^'},

169 {"circumflex-accent", '^'},

170 {"underscore", '_'},

171 {"low-line", '_'},

172 {"grave-accent", '`'},

173 {"left-brace", '{'},

174 {"left-curly-bracket", '{'},

175 {"vertical-line", '|'},

176 {"right-brace", '}'},

177 {"right-curly-bracket", '}'},

178 {"tilde", '~'},

179 {"DEL", '\177'},

180 {NULL, 0}};

181

182

183

184

185

199

200static void p_ere(struct parse *, int);

203static void p_bre(struct parse *, int, int);

223static void mcadd(struct parse *, cset *, const char *);

237

238static char nuls[10];

239

240

241

242

243

244#define PEEK() (*p->next)

245#define PEEK2() (*(p->next + 1))

246#define MORE() (p->end - p->next > 0)

247#define MORE2() (p->end - p->next > 1)

248#define SEE(c) (MORE() && PEEK() == (c))

249#define SEETWO(a, b) (MORE2() && PEEK() == (a) && PEEK2() == (b))

250#define EAT(c) ((SEE(c)) ? (NEXT(), 1) : 0)

251#define EATTWO(a, b) ((SEETWO(a, b)) ? (NEXT2(), 1) : 0)

252#define NEXT() (p->next++)

253#define NEXT2() (p->next += 2)

254#define NEXTn(n) (p->next += (n))

255#define GETNEXT() (*p->next++)

256#define SETERROR(e) seterr(p, (e))

257#define REQUIRE(co, e) (void)((co) || SETERROR(e))

258#define MUSTSEE(c, e) (REQUIRE(MORE() && PEEK() == (c), e))

259#define MUSTEAT(c, e) (REQUIRE(MORE() && GETNEXT() == (c), e))

260#define MUSTNOTSEE(c, e) (REQUIRE(!MORE() || PEEK() != (c), e))

261#define EMIT(op, sopnd) doemit(p, (sop)(op), (size_t)(sopnd))

262#define INSERT(op, pos) doinsert(p, (sop)(op), HERE() - (pos) + 1, pos)

263#define AHEAD(pos) dofwd(p, pos, HERE() - (pos))

264#define ASTERN(sop, pos) EMIT(sop, HERE() - pos)

265#define HERE() (p->slen)

266#define THERE() (p->slen - 1)

267#define THERETHERE() (p->slen - 2)

268#define DROP(n) (p->slen -= (n))

269

270#ifdef _POSIX2_RE_DUP_MAX

271#define DUPMAX _POSIX2_RE_DUP_MAX

272#else

273#define DUPMAX 255

274#endif

275#define REGINFINITY (DUPMAX + 1)

276

277#ifndef NDEBUG

278static int never = 0;

279#else

280#define never 0

281#endif

282

283

284

285

286int

290 struct parse *p = &pa;

291 int i;

292 size_t len;

293#ifdef REDEBUG

294#define GOODFLAGS(f) (f)

295#else

296#define GOODFLAGS(f) ((f) & ~REG_DUMP)

297#endif

298

302

304 if (preg->re_endp < pattern)

306 len = preg->re_endp - pattern;

307 } else {

308 len = strlen(pattern);

309 }

310

311

313 (NC - 1) * sizeof(cat_t));

314 if (g == NULL)

316 p->ssize = len / (size_t)2 * (size_t)3 + (size_t)1;

317 p->strip = (sop *)calloc(p->ssize, sizeof(sop));

318 p->slen = 0;

319 if (p->strip == NULL) {

320 free((char *)g);

322 }

323

324

325 p->g = g;

326 p->next = pattern;

327 p->end = p->next + len;

328 p->error = 0;

329 p->ncsalloc = 0;

330 for (i = 0; i < NPAREN; i++) {

331 p->pbegin[i] = 0;

332 p->pend[i] = 0;

333 }

334 g->csetsize = NC;

335 g->sets = NULL;

336 g->setbits = NULL;

337 g->ncsets = 0;

339 g->iflags = 0;

340 g->nbol = 0;

341 g->neol = 0;

342 g->must = NULL;

343 g->mlen = 0;

344 g->nsub = 0;

345 g->ncategories = 1;

346 g->categories = &g->catspace[-(CHAR_MIN)];

347 (void)memset((char *)g->catspace, 0, NC * sizeof(cat_t));

348 g->backrefs = 0;

349

350

352 g->firststate = THERE();

357 else

360 g->laststate = THERE();

361

362

371#ifndef REDEBUG

372

375#endif

376

377

378 if (p->error != 0)

380 return (p->error);

381}

382

383

384

385

387 int stop)

388{

389 char c;

390 sopno prevback = 0;

391 sopno prevfwd = 0;

393 int first = 1;

394

395 for (;;) {

396

397 conc = HERE();

398 while (MORE() && (c = PEEK()) != '|' && c != stop)

401

402 if ( EAT ('|'))

403 break;

404

405 if (first) {

406 INSERT(OCH_, conc);

407 prevfwd = conc;

408 prevback = conc;

409 first = 0;

410 }

412 prevback = THERE();

413 AHEAD(prevfwd);

414 prevfwd = HERE();

415 EMIT(OOR2, 0);

416 }

417

418 if (!first) {

421 }

422

424}

425

426

427

428

430 char c;

432 int count;

433 int count2;

434 int backrefnum;

436 int wascaret = 0;

437

438 assert(MORE());

440

441 pos = HERE();

442 switch (c) {

443 case '(':

445 p->g->nsub++;

446 subno = p->g->nsub;

448 p->pbegin[subno] = HERE();

450 if ( SEE (')'))

452 if (subno < NPAREN) {

453 p->pend[subno] = HERE();

454 assert(p->pend[subno] != 0);

455 }

458 break;

459#ifndef POSIX_MISTAKE

460 case ')':

461

462

463

464

465

466

467

469 break;

470#endif

471 case '^':

473 p->g->iflags |= USEBOL;

474 p->g->nbol++;

475 wascaret = 1;

476 break;

477 case '$':

479 p->g->iflags |= USEEOL;

480 p->g->neol++;

481 break;

482 case '|':

484 break;

485 case '*':

486 case '+':

487 case '?':

489 break;

490 case '.':

493 else

495 break;

496 case '[':

498 break;

499 case '\\':

502 if (c >= '1' && c <= '9') {

503

504

505

506

507

508 backrefnum = c - '0';

509 if (p->pend[backrefnum] == 0) {

511 break;

512 }

513

514

515

516

517 assert(backrefnum <= p->g->nsub);

519 assert(p->pbegin[backrefnum] != 0);

522 (void)dupl(p, p->pbegin[backrefnum] + 1, p->pend[backrefnum]);

524 p->g->backrefs = 1;

525 } else {

526

527

529 }

530 break;

531 case '{':

534 default:

536 break;

537 }

538

540 return;

542

543 if (!(c == '*' || c == '+' || c == '?' ||

545 return;

547

549 switch (c) {

550 case '*':

551

556 break;

557 case '+':

560 break;

561 case '?':

562

563 INSERT(OCH_, pos);

564 ASTERN(OOR1, pos);

565 AHEAD(pos);

566 EMIT(OOR2, 0);

569 break;

570 case '{':

572 if (EAT(',')) {

573 if (isdigit((uch)PEEK())) {

576 } else

578 } else

579 count2 = count;

580 repeat(p, pos, count, count2);

581 if ( EAT ('}')) {

582 while (MORE() && PEEK() != '}')

586 }

587 break;

588 }

589

591 return;

593 if (!(c == '*' || c == '+' || c == '?' ||

595 return;

597}

598

599

600

601

607

608

609

610

611

612

613

614

615

616

617

618static void p_bre(struct parse *p, int end1,

619 int end2)

620{

622 int first = 1;

623 int wasdollar = 0;

624

625 if (EAT('^')) {

627 p->g->iflags |= USEBOL;

628 p->g->nbol++;

629 }

630 while (MORE() && SEETWO (end1, end2)) {

632 first = 0;

633 }

634 if (wasdollar) {

637 p->g->iflags |= USEEOL;

638 p->g->neol++;

639 }

640

642}

643

644

645

646

647static int

649 int starordinary)

650{

651 int c;

652 int count;

653 int count2;

655 int i;

657#define BACKSL (1 << CHAR_BIT)

658

659 pos = HERE();

660

661 assert(MORE());

663 if (c == '\\') {

666 }

667 switch (c) {

668 case '.':

671 else

673 break;

674 case '[':

676 break;

679 break;

681 p->g->nsub++;

682 subno = p->g->nsub;

684 p->pbegin[subno] = HERE();

686

688 p_bre(p, '\\', ')');

689 if (subno < NPAREN) {

690 p->pend[subno] = HERE();

691 assert(p->pend[subno] != 0);

692 }

695 break;

696 case BACKSL | ')':

699 break;

711 if (p->pend[i] != 0) {

714 assert(p->pbegin[i] != 0);

717 (void)dupl(p, p->pbegin[i] + 1, p->pend[i]);

719 } else {

721 }

722 p->g->backrefs = 1;

723 break;

724 case '*':

727 default:

729 break;

730 }

731

732 if (EAT('*')) {

733

738 } else if (EATTWO('\\', '{')) {

740 if (EAT(',')) {

744 } else

746 } else

747 count2 = count;

748 repeat(p, pos, count, count2);

749 if ( EATTWO ('\\', '}')) {

754 }

755 } else if (c == '$')

756 return (1);

757

758 return (0);

759}

760

761

762

763

764static int

766 int count = 0;

767 int ndigits = 0;

768

770 count = count * 10 + (GETNEXT() - '0');

771 ndigits++;

772 }

773

775 return (count);

776}

777

778

779

780

781

782

783

786 int invert = 0;

787

788

789 if (p->end - p->next > 5) {

790 if (strncmp(p->next, "[:<:]]", 6) == 0) {

793 return;

794 }

795 if (strncmp(p->next, "[:>:]]", 6) == 0) {

798 return;

799 }

800 }

801

802 if ((cs = allocset(p)) == NULL) {

803

804 return;

805 }

806

807 if (EAT('^'))

808 invert++;

809 if (EAT(']'))

811 else if (EAT('-'))

815 if (EAT('-'))

818

819 if (p->error != 0) {

821 return;

822 }

823

825 int i;

826 int ci;

827

828 for (i = p->g->csetsize - 1; i >= 0; i--)

829 if (CHIN(cs, i) && isalpha(i)) {

831 if (ci != i)

833 }

834 if (cs->multis != NULL)

836 }

837 if (invert) {

838 int i;

839

840 for (i = p->g->csetsize - 1; i >= 0; i--)

841 if (CHIN(cs, i))

843 else

847 if (cs->multis != NULL)

849 }

850

852

853 if (nch(p, cs) == 1) {

856 } else {

858 }

859}

860

861

862

863

865 char c;

866 char start, finish;

867 int i;

868

869

870 switch ((MORE()) ? PEEK() : '\0') {

871 case '[':

873 break;

874 case '-':

876 return;

877 break;

878 default:

879 c = '\0';

880 break;

881 }

882

883 switch (c) {

884 case ':':

892 break;

893 case '=':

901 break;

902 default:

903

906

908 if (EAT('-'))

909 finish = '-';

910 else

912 } else {

913 finish = start;

914 }

915

917 for (i = start; i <= finish; i++)

919 break;

920 }

921}

922

923

924

925

927 const char *sp = p->next;

929 size_t len;

930 const char *u;

931 char c;

932

935 len = p->next - sp;

937 if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0')

938 break;

939 if (cp->name == NULL) {

940

942 return;

943 }

944

946 while ((c = *u++) != '\0')

948 for (u = cp->multis; *u != '\0'; u += strlen(u) + 1)

950}

951

952

953

954

955

956

963

964

965

966

967static char

969 char value;

970

972 if ( EATTWO ('[', '.'))

974

975

978 return (value);

979}

980

981

982

983

984static char

986{

987 const char *sp = p->next;

988 struct cname *cp;

989 size_t len;

990

993 if ( MORE ()) {

995 return (0);

996 }

997 len = p->next - sp;

998 for (cp = cnames; cp->name != NULL; cp++)

999 if (strncmp(cp->name, sp, len) == 0 && strlen(cp->name) == len)

1000 return (cp->code);

1001 if (len == 1)

1002 return (*sp);

1004 return (0);

1005}

1006

1007

1008

1009

1010static char

1012 ch = (uch)ch;

1013 assert(isalpha(ch));

1014 if (isupper(ch))

1015 return ((uch)tolower(ch));

1016 else if (islower(ch))

1017 return ((uch)toupper(ch));

1018 else

1019 return (ch);

1020}

1021

1022

1023

1024

1025

1026

1028 const char *oldnext = p->next;

1029 const char *oldend = p->end;

1030 char bracket[3];

1031

1032 ch = (uch)ch;

1033 assert(othercase(ch) != ch);

1034 p->next = bracket;

1035 p->end = bracket + 2;

1036 bracket[0] = ch;

1037 bracket[1] = ']';

1038 bracket[2] = '\0';

1040 assert(p->next == bracket + 2);

1041 p->next = oldnext;

1042 p->end = oldend;

1043}

1044

1045

1046

1047

1049 cat_t *cap = p->g->categories;

1050

1053 else {

1055 if (cap[ch] == 0)

1056 cap[ch] = p->g->ncategories++;

1057 }

1058}

1059

1060

1061

1062

1063

1064

1066 const char *oldnext = p->next;

1067 const char *oldend = p->end;

1068 static const char bracket[4] = {'^', '\n', ']', '\0'};

1069

1070 p->next = bracket;

1071 p->end = bracket + 3;

1073 assert(p->next == bracket + 3);

1074 p->next = oldnext;

1075 p->end = oldend;

1076}

1077

1078

1079

1080

1082 sopno start,

1083 int from,

1084 int to)

1085{

1087#define N 2

1088#define INF 3

1089#define REP(f, t) ((f) * 8 + (t))

1090#define MAP(n) (((n) <= 1) ? (n) : ((n) == REGINFINITY) ? INF : N)

1092

1093 if (p->error != 0)

1094 return;

1095

1097

1098 switch (REP(MAP(from), MAP(to))) {

1099 case REP(0, 0):

1100 DROP(finish - start);

1101 break;

1102 case REP(0, 1):

1103 case REP(0, N):

1104 case REP(0, INF):

1105

1106 INSERT(OCH_, start);

1107 repeat(p, start + 1, 1, to);

1109 AHEAD(start);

1113 break;

1114 case REP(1, 1):

1115

1116 break;

1117 case REP(1, N):

1118

1122 EMIT(OOR2, 0);

1125 copy = dupl(p, start + 1, finish + 1);

1126 assert(copy == finish + 4);

1127 repeat(p, copy, 1, to - 1);

1128 break;

1129 case REP(1, INF):

1132 break;

1133 case REP(N, N):

1134 copy = dupl(p, start, finish);

1135 repeat(p, copy, from - 1, to - 1);

1136 break;

1137 case REP(N, INF):

1138 copy = dupl(p, start, finish);

1139 repeat(p, copy, from - 1, to);

1140 break;

1141 default:

1143 break;

1144 }

1145}

1146

1147

1148

1149

1150static int

1152 if (p->error == 0)

1153 p->error = e;

1154 p->next = nuls;

1155 p->end = nuls;

1156 return (0);

1157}

1158

1159

1160

1161

1163 int no = p->g->ncsets++;

1164 size_t nc;

1165 size_t nbytes;

1167 size_t css = (size_t)p->g->csetsize;

1168 int i;

1169

1170 if (no >= p->ncsalloc) {

1171 void *ptr;

1172

1173 p->ncsalloc += CHAR_BIT;

1174 nc = p->ncsalloc;

1175 if (nc > SIZE_MAX / sizeof(cset))

1176 goto nomem;

1177 assert(nc % CHAR_BIT == 0);

1178 nbytes = nc / CHAR_BIT * css;

1179

1180 ptr = (cset *)realloc((char *)p->g->sets, nc * sizeof(cset));

1181 if (ptr == NULL)

1182 goto nomem;

1183 p->g->sets = ptr;

1184

1185 ptr = (uch *)realloc((char *)p->g->setbits, nbytes);

1186 if (ptr == NULL)

1187 goto nomem;

1188 p->g->setbits = ptr;

1189

1190 for (i = 0; i < no; i++)

1191 p->g->sets[i].ptr = p->g->setbits + css * (i / CHAR_BIT);

1192

1193 (void)memset((char *)p->g->setbits + (nbytes - css), 0, css);

1194 }

1195

1196 if (p->g->sets == NULL || p->g->setbits == NULL)

1197 goto nomem;

1198

1199 cs = &p->g->sets[no];

1200 cs->ptr = p->g->setbits + css * ((no) / CHAR_BIT);

1201 cs->mask = 1 << ((no) % CHAR_BIT);

1202 cs->hash = 0;

1205

1206 return (cs);

1207nomem:

1208 free(p->g->sets);

1209 p->g->sets = NULL;

1210 free(p->g->setbits);

1211 p->g->setbits = NULL;

1212

1214

1215 return (NULL);

1216}

1217

1218

1219

1220

1222 size_t i;

1223 cset *top = &p->g->sets[p->g->ncsets];

1224 size_t css = (size_t)p->g->csetsize;

1225

1226 for (i = 0; i < css; i++)

1228 if (cs == top - 1)

1229 p->g->ncsets--;

1230}

1231

1232

1233

1234

1235

1236

1237

1238

1239

1240

1241static int

1244 size_t i;

1245 cset *top = &p->g->sets[p->g->ncsets];

1247 size_t css = (size_t)p->g->csetsize;

1248

1249

1250 for (cs2 = &p->g->sets[0]; cs2 < top; cs2++)

1251 if (cs2->hash == h && cs2 != cs) {

1252

1253 for (i = 0; i < css; i++)

1254 if (! CHIN (cs2, i) != ! CHIN (cs, i))

1255 break;

1256 if (i == css)

1257 break;

1258 }

1259

1260 if (cs2 < top) {

1262 cs = cs2;

1263 }

1264

1265 return ((int)(cs - p->g->sets));

1266}

1267

1268

1269

1270

1271static int

1273 size_t i;

1274 size_t css = (size_t)p->g->csetsize;

1275

1276 for (i = 0; i < css; i++)

1277 if (CHIN(cs, i))

1278 return ((char)i);

1280 return (0);

1281}

1282

1283

1284

1285

1287 size_t i;

1288 size_t css = (size_t)p->g->csetsize;

1289 int n = 0;

1290

1291 for (i = 0; i < css; i++)

1292 if (CHIN(cs, i))

1293 n++;

1294 return (n);

1295}

1296

1297

1298

1299

1301 size_t oldend = cs->smultis;

1302 void *np;

1303

1304 cs->smultis += strlen(cp) + 1;

1306 if (np == NULL) {

1311 return;

1312 }

1314

1316}

1317

1318

1319

1320

1321

1322

1323

1324

1328

1329

1330

1331

1332

1333

1334

1335

1339

1340

1341

1342

1343static int

1345 uch *col;

1346 int i;

1347 int ncols = (g->ncsets + (CHAR_BIT - 1)) / CHAR_BIT;

1348 unsigned uc = (uch)c;

1349

1350 for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)

1351 if (col[uc] != 0)

1352 return (1);

1353 return (0);

1354}

1355

1356

1357

1358

1359static int

1361 uch *col;

1362 int i;

1363 int ncols = (g->ncsets + (CHAR_BIT - 1)) / CHAR_BIT;

1364 unsigned uc1 = (uch)c1;

1365 unsigned uc2 = (uch)c2;

1366

1367 for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)

1368 if (col[uc1] != col[uc2])

1369 return (0);

1370 return (1);

1371}

1372

1373

1374

1375

1377 cat_t *cats = g->categories;

1378 int c;

1379 int c2;

1381

1382

1383 if (p->error != 0)

1384 return;

1385

1386 for (c = CHAR_MIN; c <= CHAR_MAX; c++)

1387 if (cats[c] == 0 && isinsets(g, c)) {

1388 cat = g->ncategories++;

1389 cats[c] = cat;

1390 for (c2 = c + 1; c2 <= CHAR_MAX; c2++)

1391 if (cats[c2] == 0 && samesets(g, c, c2))

1392 cats[c2] = cat;

1393 }

1394}

1395

1396

1397

1398

1399static sopno

1401 sopno finish)

1402{

1404 sopno len = finish - start;

1405

1406 assert(finish >= start);

1407 if (len == 0)

1408 return (ret);

1409 enlarge(p, p->ssize + len);

1410 assert(p->ssize >= p->slen + len);

1411 (void)memmove((char *)(p->strip + p->slen), (char *)(p->strip + start),

1412 (size_t)len * sizeof(sop));

1413 p->slen += len;

1414 return (ret);

1415}

1416

1417

1418

1419

1420

1421

1422

1423

1425

1426 if (p->error != 0)

1427 return;

1428

1429

1431

1432

1433 if (p->slen >= p->ssize)

1434 enlarge(p, (p->ssize + 1) / 2 * 3);

1435 assert(p->slen < p->ssize);

1436

1437

1438 p->strip[p->slen++] = SOP(op, opnd);

1439}

1440

1441

1442

1443

1447 int i;

1448

1449

1450 if (p->error != 0)

1451 return;

1452

1453 sn = HERE();

1454 EMIT(op, opnd);

1456 s = p->strip[sn];

1457

1458

1460 for (i = 1; i < NPAREN; i++) {

1461 if (p->pbegin[i] >= pos) {

1462 p->pbegin[i]++;

1463 }

1464 if (p->pend[i] >= pos) {

1465 p->pend[i]++;

1466 }

1467 }

1468

1469 memmove((char *)&p->strip[pos + 1], (char *)&p->strip[pos],

1470 (HERE() - pos - 1) * sizeof(sop));

1471 p->strip[pos] = s;

1472}

1473

1474

1475

1476

1478

1479 if (p->error != 0)

1480 return;

1481

1483 p->strip[pos] = OP(p->strip[pos]) | value;

1484}

1485

1486

1487

1488

1490 sop *sp;

1491

1492 if (p->ssize >= size)

1493 return;

1494

1495 if ((uintptr_t)size > SIZE_MAX / sizeof(sop)) {

1497 return;

1498 }

1499

1500 sp = (sop *)realloc(p->strip, size * sizeof(sop));

1501 if (sp == NULL) {

1503 return;

1504 }

1505 p->strip = sp;

1506 p->ssize = size;

1507}

1508

1509

1510

1511

1513 g->nstates = p->slen;

1514 if ((uintptr_t)p->slen > SIZE_MAX / sizeof(sop)) {

1515 g->strip = p->strip;

1517 return;

1518 }

1519

1520 g->strip = (sop *)realloc((char *)p->strip, p->slen * sizeof(sop));

1521 if (g->strip == NULL) {

1523 g->strip = p->strip;

1524 }

1525}

1526

1527

1528

1529

1530

1531

1532

1533

1534

1535

1537 sop *scan;

1538 sop *start = 0;

1539 sop *newstart = 0;

1542 char *cp;

1544

1545

1546 if (p->error != 0)

1547 return;

1548

1549

1550 newlen = 0;

1551 scan = g->strip + 1;

1552 do {

1553 s = *scan++;

1554 switch (OP(s)) {

1555 case OCHAR:

1556 if (newlen == 0)

1557 newstart = scan - 1;

1558 newlen++;

1559 break;

1560 case OPLUS_:

1563 break;

1564 case OQUEST_:

1566 scan--;

1567 do {

1568 scan += OPND(s);

1569 s = *scan;

1570

1573 return;

1574 }

1577 default:

1578 if (newlen > g->mlen) {

1579 start = newstart;

1580 g->mlen = newlen;

1581 }

1582 newlen = 0;

1583 break;

1584 }

1585 } while (OP(s) != OEND);

1586

1587 if (g->mlen == 0)

1588 return;

1589

1590

1591 g->must = malloc((size_t)g->mlen + 1);

1592 if (g->must == NULL) {

1593 g->mlen = 0;

1594 return;

1595 }

1596 cp = g->must;

1597 scan = start;

1598 for (i = g->mlen; i > 0; i--) {

1599 while (OP(s = *scan++) != OCHAR)

1600 continue;

1601 assert(cp < g->must + g->mlen);

1603 }

1604 assert(cp == g->must + g->mlen);

1605 *cp++ = '\0';

1606}

1607

1608

1609

1610

1611static sopno

1613 sop *scan;

1615 sopno plusnest = 0;

1616 sopno maxnest = 0;

1617

1618 if (p->error != 0)

1619 return (0);

1620

1621 scan = g->strip + 1;

1622 do {

1623 s = *scan++;

1624 switch (OP(s)) {

1626 plusnest++;

1627 break;

1629 if (plusnest > maxnest)

1630 maxnest = plusnest;

1631 plusnest--;

1632 break;

1633 }

1634 } while (OP(s) != OEND);

1635 if (plusnest != 0)

1637 return (maxnest);

1638}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

#define LLVM_FALLTHROUGH

LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.

INLINE void g(uint32_t *state, size_t a, size_t b, size_t c, size_t d, uint32_t x, uint32_t y)

static void mccase(struct parse *, cset *)

Definition regcomp.c:1336

static int samesets(struct re_guts *, int, int)

Definition regcomp.c:1360

static void stripsnug(struct parse *, struct re_guts *)

Definition regcomp.c:1512

#define NEXT2()

Definition regcomp.c:253

#define HERE()

Definition regcomp.c:265

static void mcadd(struct parse *, cset *, const char *)

Definition regcomp.c:1300

static char p_b_coll_elem(struct parse *, int)

Definition regcomp.c:985

#define SEETWO(a, b)

Definition regcomp.c:249

#define GETNEXT()

Definition regcomp.c:255

static void p_ere_exp(struct parse *)

Definition regcomp.c:429

static sopno dupl(struct parse *, sopno, sopno)

Definition regcomp.c:1400

#define DROP(n)

Definition regcomp.c:268

#define never

Definition regcomp.c:280

static char othercase(int)

Definition regcomp.c:1011

static void p_b_cclass(struct parse *, cset *)

Definition regcomp.c:926

static void doemit(struct parse *, sop, size_t)

Definition regcomp.c:1424

#define NPAREN

Definition regcomp.c:195

static void nonnewline(struct parse *)

Definition regcomp.c:1065

static void p_b_eclass(struct parse *, cset *)

Definition regcomp.c:957

static int freezeset(struct parse *, cset *)

Definition regcomp.c:1242

#define ASTERN(sop, pos)

Definition regcomp.c:264

#define AHEAD(pos)

Definition regcomp.c:263

static struct cclass cclasses[]

static struct cname cnames[]

static void ordinary(struct parse *, int)

Definition regcomp.c:1048

#define MUSTEAT(c, e)

Definition regcomp.c:259

#define SETERROR(e)

Definition regcomp.c:256

#define PEEK2()

Definition regcomp.c:245

static void categorize(struct parse *, struct re_guts *)

Definition regcomp.c:1376

static void p_str(struct parse *)

Definition regcomp.c:602

#define DUPMAX

Definition regcomp.c:273

static void bothcases(struct parse *, int)

Definition regcomp.c:1027

#define INSERT(op, pos)

Definition regcomp.c:262

static char nuls[10]

Definition regcomp.c:238

static void repeat(struct parse *, sopno, int, int)

Definition regcomp.c:1081

int llvm_regcomp(llvm_regex_t *preg, const char *pattern, int cflags)

Definition regcomp.c:287

static void p_b_term(struct parse *, cset *)

Definition regcomp.c:864

static int isinsets(struct re_guts *, int)

Definition regcomp.c:1344

#define NEXTn(n)

Definition regcomp.c:254

#define PEEK()

Definition regcomp.c:244

#define SEE(c)

Definition regcomp.c:248

static void p_bre(struct parse *, int, int)

Definition regcomp.c:618

#define THERE()

Definition regcomp.c:266

static int nch(struct parse *, cset *)

Definition regcomp.c:1286

static void doinsert(struct parse *, sop, size_t, sopno)

Definition regcomp.c:1444

static sopno pluscount(struct parse *, struct re_guts *)

Definition regcomp.c:1612

static void p_ere(struct parse *, int)

Definition regcomp.c:386

static char p_b_symbol(struct parse *)

Definition regcomp.c:968

#define MORE()

Definition regcomp.c:246

static void findmust(struct parse *, struct re_guts *)

Definition regcomp.c:1536

static cset * allocset(struct parse *)

Definition regcomp.c:1162

static void p_bracket(struct parse *)

Definition regcomp.c:784

static void dofwd(struct parse *, sopno, sop)

Definition regcomp.c:1477

static int p_count(struct parse *)

Definition regcomp.c:765

static void enlarge(struct parse *, sopno)

Definition regcomp.c:1489

#define REGINFINITY

Definition regcomp.c:275

#define MORE2()

Definition regcomp.c:247

#define REQUIRE(co, e)

Definition regcomp.c:257

#define EAT(c)

Definition regcomp.c:250

#define EMIT(op, sopnd)

Definition regcomp.c:261

#define THERETHERE()

Definition regcomp.c:267

static int p_simp_re(struct parse *, int)

Definition regcomp.c:648

static void freeset(struct parse *, cset *)

Definition regcomp.c:1221

static void mcinvert(struct parse *, cset *)

Definition regcomp.c:1325

static int seterr(struct parse *, int)

Definition regcomp.c:1151

#define NEXT()

Definition regcomp.c:252

#define EATTWO(a, b)

Definition regcomp.c:251

static int firstch(struct parse *, cset *)

Definition regcomp.c:1272

size_t llvm_strlcpy(char *dst, const char *src, size_t siz)

struct llvm_regex llvm_regex_t

void llvm_regfree(llvm_regex_t *)

const char * multis

Definition regcomp.c:57

const char * chars

Definition regcomp.c:56

const char * name

Definition regcomp.c:55

char code

Definition regcomp.c:84

const char * name

Definition regcomp.c:83

struct re_guts * g

Definition regcomp.c:194

const char * next

Definition regcomp.c:187

sopno pend[NPAREN]

Definition regcomp.c:197

sopno slen

Definition regcomp.c:192

sopno ssize

Definition regcomp.c:191

int error

Definition regcomp.c:189

const char * end

Definition regcomp.c:188

sopno pbegin[NPAREN]

Definition regcomp.c:196

sop * strip

Definition regcomp.c:190

int ncsalloc

Definition regcomp.c:193