Terraria v1.4.4.9
Terraria source code documentation
Loading...
Searching...
No Matches

◆ GenerateFindFirstChar()

void System.Text.RegularExpressions.RegexCompiler.GenerateFindFirstChar ( )
inlineprotectedinherited

Definition at line 1034 of file RegexCompiler.cs.

1035 {
1036 _int32LocalsPool?.Clear();
1037 _readOnlySpanCharLocalsPool?.Clear();
1038 _runtextposLocal = DeclareInt32();
1039 _runtextendLocal = DeclareInt32();
1040 if (_code.RightToLeft)
1041 {
1042 _runtextbegLocal = DeclareInt32();
1043 }
1044 _runtextLocal = DeclareString();
1045 _textInfoLocal = null;
1046 if (!_options.HasFlag(RegexOptions.CultureInvariant))
1047 {
1048 bool flag = _options.HasFlag(RegexOptions.IgnoreCase) || (_boyerMoorePrefix?.CaseInsensitive ?? false);
1049 if (!flag && _leadingCharClasses != null)
1050 {
1051 for (int i = 0; i < _leadingCharClasses.Length; i++)
1052 {
1053 if (_leadingCharClasses[i].CaseInsensitive)
1054 {
1055 flag = true;
1056 break;
1057 }
1058 }
1059 }
1060 if (flag)
1061 {
1062 _textInfoLocal = DeclareTextInfo();
1063 InitLocalCultureInfo();
1064 }
1065 }
1066 Mvfldloc(s_runtextposField, _runtextposLocal);
1067 Mvfldloc(s_runtextendField, _runtextendLocal);
1068 if (_code.RightToLeft)
1069 {
1070 Mvfldloc(s_runtextbegField, _runtextbegLocal);
1071 }
1072 int minRequiredLength = _code.Tree.MinRequiredLength;
1073 Label l = DefineLabel();
1074 Label l2 = DefineLabel();
1075 if (!_code.RightToLeft)
1076 {
1077 Ldloc(_runtextposLocal);
1078 Ldloc(_runtextendLocal);
1079 if (minRequiredLength > 0)
1080 {
1081 Ldc(minRequiredLength);
1082 Sub();
1083 }
1084 Ble(l2);
1085 MarkLabel(l);
1086 Ldthis();
1087 Ldloc(_runtextendLocal);
1088 }
1089 else
1090 {
1091 Ldloc(_runtextposLocal);
1092 if (minRequiredLength > 0)
1093 {
1094 Ldc(minRequiredLength);
1095 Sub();
1096 }
1097 Ldloc(_runtextbegLocal);
1098 Bge(l2);
1099 MarkLabel(l);
1100 Ldthis();
1101 Ldloc(_runtextbegLocal);
1102 }
1103 Stfld(s_runtextposField);
1104 Ldc(0);
1105 Ret();
1106 MarkLabel(l2);
1107 if (((uint)_leadingAnchor & 0x37u) != 0)
1108 {
1109 switch (_leadingAnchor)
1110 {
1111 case 1:
1112 {
1113 Label l5 = DefineLabel();
1114 Ldloc(_runtextposLocal);
1115 if (!_code.RightToLeft)
1116 {
1117 Ldthisfld(s_runtextbegField);
1118 Ble(l5);
1119 Br(l);
1120 }
1121 else
1122 {
1123 Ldloc(_runtextbegLocal);
1124 Ble(l5);
1125 Ldthis();
1126 Ldloc(_runtextbegLocal);
1127 Stfld(s_runtextposField);
1128 }
1129 MarkLabel(l5);
1130 Ldc(1);
1131 Ret();
1132 return;
1133 }
1134 case 4:
1135 {
1136 Label l4 = DefineLabel();
1137 Ldloc(_runtextposLocal);
1138 Ldthisfld(s_runtextstartField);
1139 if (!_code.RightToLeft)
1140 {
1141 Ble(l4);
1142 }
1143 else
1144 {
1145 Bge(l4);
1146 }
1147 Br(l);
1148 MarkLabel(l4);
1149 Ldc(1);
1150 Ret();
1151 return;
1152 }
1153 case 16:
1154 {
1155 Label l7 = DefineLabel();
1156 if (!_code.RightToLeft)
1157 {
1158 Ldloc(_runtextposLocal);
1159 Ldloc(_runtextendLocal);
1160 Ldc(1);
1161 Sub();
1162 Bge(l7);
1163 Ldthis();
1164 Ldloc(_runtextendLocal);
1165 Ldc(1);
1166 Sub();
1167 Stfld(s_runtextposField);
1168 MarkLabel(l7);
1169 }
1170 else
1171 {
1172 Label l8 = DefineLabel();
1173 Ldloc(_runtextposLocal);
1174 Ldloc(_runtextendLocal);
1175 Ldc(1);
1176 Sub();
1177 Blt(l7);
1178 Ldloc(_runtextposLocal);
1179 Ldloc(_runtextendLocal);
1180 Beq(l8);
1181 Ldthisfld(s_runtextField);
1182 Ldloc(_runtextposLocal);
1183 Call(s_stringGetCharsMethod);
1184 Ldc(10);
1185 Beq(l8);
1186 MarkLabel(l7);
1187 BrFar(l);
1188 MarkLabel(l8);
1189 }
1190 Ldc(1);
1191 Ret();
1192 return;
1193 }
1194 case 32:
1195 if (minRequiredLength == 0)
1196 {
1197 Label l6 = DefineLabel();
1198 Ldloc(_runtextposLocal);
1199 Ldloc(_runtextendLocal);
1200 if (!_code.RightToLeft)
1201 {
1202 Bge(l6);
1203 Ldthis();
1204 Ldloc(_runtextendLocal);
1205 Stfld(s_runtextposField);
1206 }
1207 else
1208 {
1209 Bge(l6);
1210 Br(l);
1211 }
1212 MarkLabel(l6);
1213 Ldc(1);
1214 Ret();
1215 return;
1216 }
1217 break;
1218 case 2:
1219 if (!_code.RightToLeft)
1220 {
1221 Label l3 = DefineLabel();
1222 Ldloc(_runtextposLocal);
1223 Ldthisfld(s_runtextbegField);
1224 Ble(l3);
1225 Ldthisfld(s_runtextField);
1226 Ldloc(_runtextposLocal);
1227 Ldc(1);
1228 Sub();
1229 Call(s_stringGetCharsMethod);
1230 Ldc(10);
1231 Beq(l3);
1232 Ldthisfld(s_runtextField);
1233 Ldc(10);
1234 Ldloc(_runtextposLocal);
1235 Call(s_stringIndexOfCharInt);
1236 using (RentedLocalBuilder rentedLocalBuilder = RentInt32Local())
1237 {
1238 Stloc(rentedLocalBuilder);
1239 Ldloc(rentedLocalBuilder);
1240 Ldc(-1);
1241 Beq(l);
1242 Ldloc(rentedLocalBuilder);
1243 Ldc(1);
1244 Add();
1245 Ldloc(_runtextendLocal);
1246 Bgt(l);
1247 Ldloc(rentedLocalBuilder);
1248 Ldc(1);
1249 Add();
1250 Stloc(_runtextposLocal);
1251 }
1252 MarkLabel(l3);
1253 }
1254 break;
1255 }
1256 }
1257 if (_boyerMoorePrefix != null && _boyerMoorePrefix.NegativeUnicode == null)
1258 {
1259 LocalBuilder lt;
1260 int num;
1261 int index;
1262 if (!_code.RightToLeft)
1263 {
1264 lt = _runtextendLocal;
1265 num = -1;
1266 index = _boyerMoorePrefix.Pattern.Length - 1;
1267 }
1268 else
1269 {
1270 lt = _runtextbegLocal;
1271 num = _boyerMoorePrefix.Pattern.Length;
1272 index = 0;
1273 }
1274 int i2 = _boyerMoorePrefix.Pattern[index];
1275 Mvfldloc(s_runtextField, _runtextLocal);
1276 Ldloc(_runtextposLocal);
1277 if (!_code.RightToLeft)
1278 {
1279 Ldc(_boyerMoorePrefix.Pattern.Length - 1);
1280 Add();
1281 }
1282 else
1283 {
1284 Ldc(_boyerMoorePrefix.Pattern.Length);
1285 Sub();
1286 }
1287 Stloc(_runtextposLocal);
1288 Label l9 = DefineLabel();
1289 Br(l9);
1290 Label l10 = DefineLabel();
1291 MarkLabel(l10);
1292 Ldc(_code.RightToLeft ? (-_boyerMoorePrefix.Pattern.Length) : _boyerMoorePrefix.Pattern.Length);
1293 Label l11 = DefineLabel();
1294 MarkLabel(l11);
1295 Ldloc(_runtextposLocal);
1296 Add();
1297 Stloc(_runtextposLocal);
1298 MarkLabel(l9);
1299 Ldloc(_runtextposLocal);
1300 Ldloc(lt);
1301 if (!_code.RightToLeft)
1302 {
1303 BgeFar(l);
1304 }
1305 else
1306 {
1307 BltFar(l);
1308 }
1309 Rightchar();
1310 if (_boyerMoorePrefix.CaseInsensitive)
1311 {
1312 CallToLower();
1313 }
1314 Label l12 = DefineLabel();
1315 using (RentedLocalBuilder rentedLocalBuilder2 = RentInt32Local())
1316 {
1317 Stloc(rentedLocalBuilder2);
1318 Ldloc(rentedLocalBuilder2);
1319 Ldc(i2);
1320 BeqFar(l12);
1321 Ldloc(rentedLocalBuilder2);
1322 Ldc(_boyerMoorePrefix.LowASCII);
1323 Sub();
1324 Stloc(rentedLocalBuilder2);
1325 Ldloc(rentedLocalBuilder2);
1326 Ldc(_boyerMoorePrefix.HighASCII - _boyerMoorePrefix.LowASCII);
1327 BgtUn(l10);
1328 int num2 = _boyerMoorePrefix.HighASCII - _boyerMoorePrefix.LowASCII + 1;
1329 if (num2 > 1)
1330 {
1331 string str = string.Create(num2, (this, num), delegate(Span<char> span, (RegexCompiler thisRef, int beforefirst) state)
1332 {
1333 for (int k = 0; k < span.Length; k++)
1334 {
1335 int num8 = state.thisRef._boyerMoorePrefix.NegativeASCII[k + state.thisRef._boyerMoorePrefix.LowASCII];
1336 if (num8 == state.beforefirst)
1337 {
1338 num8 = state.thisRef._boyerMoorePrefix.Pattern.Length;
1339 }
1340 else if (state.thisRef._code.RightToLeft)
1341 {
1342 num8 = -num8;
1343 }
1344 span[k] = (char)num8;
1345 }
1346 });
1347 Ldstr(str);
1348 Ldloc(rentedLocalBuilder2);
1349 Call(s_stringGetCharsMethod);
1350 if (_code.RightToLeft)
1351 {
1352 Neg();
1353 }
1354 }
1355 else
1356 {
1357 int num3 = _boyerMoorePrefix.NegativeASCII[_boyerMoorePrefix.LowASCII];
1358 if (num3 == num)
1359 {
1360 num3 = (_code.RightToLeft ? (-_boyerMoorePrefix.Pattern.Length) : _boyerMoorePrefix.Pattern.Length);
1361 }
1362 Ldc(num3);
1363 }
1364 BrFar(l11);
1365 }
1366 MarkLabel(l12);
1367 Ldloc(_runtextposLocal);
1368 using RentedLocalBuilder rentedLocalBuilder3 = RentInt32Local();
1369 Stloc(rentedLocalBuilder3);
1370 int num4 = int.MaxValue;
1371 Label l13 = default(Label);
1372 for (int num5 = _boyerMoorePrefix.Pattern.Length - 2; num5 >= 0; num5--)
1373 {
1374 int num6 = (_code.RightToLeft ? (_boyerMoorePrefix.Pattern.Length - 1 - num5) : num5);
1375 Ldloc(_runtextLocal);
1376 Ldloc(rentedLocalBuilder3);
1377 Ldc(1);
1378 Sub(_code.RightToLeft);
1379 Stloc(rentedLocalBuilder3);
1380 Ldloc(rentedLocalBuilder3);
1381 Call(s_stringGetCharsMethod);
1382 if (_boyerMoorePrefix.CaseInsensitive && ParticipatesInCaseConversion(_boyerMoorePrefix.Pattern[num6]))
1383 {
1384 CallToLower();
1385 }
1386 Ldc(_boyerMoorePrefix.Pattern[num6]);
1387 if (num4 == _boyerMoorePrefix.Positive[num6])
1388 {
1389 BneFar(l13);
1390 }
1391 else
1392 {
1393 Label l14 = DefineLabel();
1394 Beq(l14);
1395 l13 = DefineLabel();
1396 num4 = _boyerMoorePrefix.Positive[num6];
1397 MarkLabel(l13);
1398 Ldc(num4);
1399 BrFar(l11);
1400 MarkLabel(l14);
1401 }
1402 }
1403 Ldthis();
1404 Ldloc(rentedLocalBuilder3);
1405 if (_code.RightToLeft)
1406 {
1407 Ldc(1);
1408 Add();
1409 }
1410 Stfld(s_runtextposField);
1411 Ldc(1);
1412 Ret();
1413 return;
1414 }
1415 if (_leadingCharClasses == null)
1416 {
1417 Ldc(1);
1418 Ret();
1419 return;
1420 }
1421 if (_code.RightToLeft)
1422 {
1423 using (RentedLocalBuilder rentedLocalBuilder4 = RentInt32Local())
1424 {
1425 Label l15 = DefineLabel();
1426 Label l16 = DefineLabel();
1427 Label l17 = DefineLabel();
1428 Label l18 = DefineLabel();
1429 Label l19 = DefineLabel();
1430 Mvfldloc(s_runtextField, _runtextLocal);
1431 Ldloc(_runtextposLocal);
1432 Ldloc(_runtextbegLocal);
1433 Sub();
1434 Stloc(rentedLocalBuilder4);
1435 if (minRequiredLength == 0)
1436 {
1437 Ldloc(rentedLocalBuilder4);
1438 Ldc(0);
1439 BleFar(l18);
1440 }
1441 MarkLabel(l15);
1442 Ldloc(rentedLocalBuilder4);
1443 Ldc(1);
1444 Sub();
1445 Stloc(rentedLocalBuilder4);
1446 Leftcharnext();
1447 if (!RegexCharClass.IsSingleton(_leadingCharClasses[0].CharClass))
1448 {
1449 EmitMatchCharacterClass(_leadingCharClasses[0].CharClass, _leadingCharClasses[0].CaseInsensitive);
1450 Brtrue(l16);
1451 }
1452 else
1453 {
1454 Ldc(RegexCharClass.SingletonChar(_leadingCharClasses[0].CharClass));
1455 Beq(l16);
1456 }
1457 MarkLabel(l19);
1458 Ldloc(rentedLocalBuilder4);
1459 Ldc(0);
1460 if (!RegexCharClass.IsSingleton(_leadingCharClasses[0].CharClass))
1461 {
1462 BgtFar(l15);
1463 }
1464 else
1465 {
1466 Bgt(l15);
1467 }
1468 Ldc(0);
1469 Br(l17);
1470 MarkLabel(l16);
1471 Ldloc(_runtextposLocal);
1472 Ldc(1);
1473 Sub(_code.RightToLeft);
1474 Stloc(_runtextposLocal);
1475 Ldc(1);
1476 MarkLabel(l17);
1477 Mvlocfld(_runtextposLocal, s_runtextposField);
1478 Ret();
1479 MarkLabel(l18);
1480 Ldc(0);
1481 Ret();
1482 return;
1483 }
1484 }
1485 if (minRequiredLength < _leadingCharClasses.Length)
1486 {
1487 Ldloc(_runtextendLocal);
1488 if (_leadingCharClasses.Length > 1)
1489 {
1490 Ldc(_leadingCharClasses.Length - 1);
1491 Sub();
1492 }
1493 Ldloc(_runtextposLocal);
1494 BleFar(l);
1495 }
1496 using RentedLocalBuilder rentedLocalBuilder6 = RentInt32Local();
1497 using RentedLocalBuilder rentedLocalBuilder5 = RentReadOnlySpanCharLocal();
1498 Ldthisfld(s_runtextField);
1499 Ldloc(_runtextposLocal);
1500 Ldloc(_runtextendLocal);
1501 Ldloc(_runtextposLocal);
1502 Sub();
1503 Call(s_stringAsSpanIntIntMethod);
1504 Stloc(rentedLocalBuilder5);
1505 Span<char> chars = stackalloc char[3];
1506 int num7 = 0;
1507 int j = 0;
1508 bool flag2 = !_leadingCharClasses[0].CaseInsensitive && (num7 = RegexCharClass.GetSetChars(_leadingCharClasses[0].CharClass, chars)) > 0 && !RegexCharClass.IsNegated(_leadingCharClasses[0].CharClass);
1509 bool flag3 = !flag2 || _leadingCharClasses.Length > 1;
1510 Label l20 = default(Label);
1511 Label l21 = default(Label);
1512 Label l22 = default(Label);
1513 if (flag3)
1514 {
1515 l20 = DefineLabel();
1516 l21 = DefineLabel();
1517 l22 = DefineLabel();
1518 Ldc(0);
1519 Stloc(rentedLocalBuilder6);
1520 BrFar(l20);
1521 MarkLabel(l22);
1522 }
1523 if (flag2)
1524 {
1525 j = 1;
1526 if (flag3)
1527 {
1528 Ldloca(rentedLocalBuilder5);
1529 Ldloc(rentedLocalBuilder6);
1530 Call(s_spanSliceIntMethod);
1531 }
1532 else
1533 {
1534 Ldloc(rentedLocalBuilder5);
1535 }
1536 switch (num7)
1537 {
1538 case 1:
1539 Ldc(chars[0]);
1540 Call(s_spanIndexOf);
1541 break;
1542 case 2:
1543 Ldc(chars[0]);
1544 Ldc(chars[1]);
1545 Call(s_spanIndexOfAnyCharChar);
1546 break;
1547 default:
1548 Ldc(chars[0]);
1549 Ldc(chars[1]);
1550 Ldc(chars[2]);
1551 Call(s_spanIndexOfAnyCharCharChar);
1552 break;
1553 }
1554 if (flag3)
1555 {
1556 using RentedLocalBuilder rentedLocalBuilder7 = RentInt32Local();
1557 Stloc(rentedLocalBuilder7);
1558 Ldloc(rentedLocalBuilder6);
1559 Ldloc(rentedLocalBuilder7);
1560 Add();
1561 Stloc(rentedLocalBuilder6);
1562 Ldloc(rentedLocalBuilder7);
1563 Ldc(0);
1564 BltFar(l);
1565 }
1566 else
1567 {
1568 Stloc(rentedLocalBuilder6);
1569 Ldloc(rentedLocalBuilder6);
1570 Ldc(0);
1571 BltFar(l);
1572 }
1573 if (_leadingCharClasses.Length > 1)
1574 {
1575 Ldloca(rentedLocalBuilder5);
1576 Call(s_spanGetLengthMethod);
1577 Ldc(_leadingCharClasses.Length - 1);
1578 Sub();
1579 Ldloc(rentedLocalBuilder6);
1580 BleFar(l);
1581 }
1582 }
1583 for (; j < _leadingCharClasses.Length; j++)
1584 {
1585 Ldloca(rentedLocalBuilder5);
1586 Ldloc(rentedLocalBuilder6);
1587 if (j > 0)
1588 {
1589 Ldc(j);
1590 Add();
1591 }
1592 Call(s_spanGetItemMethod);
1593 LdindU2();
1594 EmitMatchCharacterClass(_leadingCharClasses[j].CharClass, _leadingCharClasses[j].CaseInsensitive);
1595 BrfalseFar(l21);
1596 }
1597 Ldthis();
1598 Ldloc(_runtextposLocal);
1599 Ldloc(rentedLocalBuilder6);
1600 Add();
1601 Stfld(s_runtextposField);
1602 Ldc(1);
1603 Ret();
1604 if (flag3)
1605 {
1606 MarkLabel(l21);
1607 Ldloc(rentedLocalBuilder6);
1608 Ldc(1);
1609 Add();
1610 Stloc(rentedLocalBuilder6);
1611 MarkLabel(l20);
1612 Ldloc(rentedLocalBuilder6);
1613 Ldloca(rentedLocalBuilder5);
1614 Call(s_spanGetLengthMethod);
1615 if (_leadingCharClasses.Length > 1)
1616 {
1617 Ldc(_leadingCharClasses.Length - 1);
1618 Sub();
1619 }
1620 BltFar(l22);
1621 BrFar(l);
1622 }
1623 }
System.Text.RegularExpressions.RegexCompiler.s_runtextstartField
static readonly FieldInfo s_runtextstartField
Definition RegexCompiler.cs:55
System.Text.RegularExpressions.RegexCompiler.EmitMatchCharacterClass
void EmitMatchCharacterClass(string charClass, bool caseInsensitive)
Definition RegexCompiler.cs:3892
System.Text.RegularExpressions.RegexCompiler.s_stringAsSpanIntIntMethod
static readonly MethodInfo s_stringAsSpanIntIntMethod
Definition RegexCompiler.cs:152
System.Text.RegularExpressions.RegexCompiler.s_spanIndexOfAnyCharChar
static readonly MethodInfo s_spanIndexOfAnyCharChar
Definition RegexCompiler.cs:121
System.Text.RegularExpressions.RegexCompiler.s_runtextendField
static readonly FieldInfo s_runtextendField
Definition RegexCompiler.cs:53
System.Text.RegularExpressions.RegexCompiler.s_spanSliceIntMethod
static readonly MethodInfo s_spanSliceIntMethod
Definition RegexCompiler.cs:136
System.Text.RegularExpressions.RegexCompiler._leadingCharClasses
string bool CaseInsensitive[] _leadingCharClasses
Definition RegexCompiler.cs:201
System.Text.RegularExpressions.RegexCompiler.s_stringGetCharsMethod
static readonly MethodInfo s_stringGetCharsMethod
Definition RegexCompiler.cs:159
System.Text.RegularExpressions.RegexCompiler.Mvlocfld
void Mvlocfld(LocalBuilder lt, FieldInfo ft)
Definition RegexCompiler.cs:495
System.Text.RegularExpressions.RegexCompiler.s_spanGetItemMethod
static readonly MethodInfo s_spanGetItemMethod
Definition RegexCompiler.cs:109
System.Text.RegularExpressions.RegexCompiler.ParticipatesInCaseConversion
static bool ParticipatesInCaseConversion(int comparison)
Definition RegexCompiler.cs:929
System.Text.RegularExpressions.RegexCompiler.s_spanIndexOfAnyCharCharChar
static readonly MethodInfo s_spanIndexOfAnyCharCharChar
Definition RegexCompiler.cs:128
System.Text.RegularExpressions.RegexCompiler.s_runtextbegField
static readonly FieldInfo s_runtextbegField
Definition RegexCompiler.cs:51
System.Text.RegularExpressions.RegexCompiler.s_stringIndexOfCharInt
static readonly MethodInfo s_stringIndexOfCharInt
Definition RegexCompiler.cs:161
System.Text.RegularExpressions.RegexCompiler.s_spanGetLengthMethod
static readonly MethodInfo s_spanGetLengthMethod
Definition RegexCompiler.cs:111
System.Text.RegularExpressions.RegexCompiler.s_runtextposField
static readonly FieldInfo s_runtextposField
Definition RegexCompiler.cs:57
System.Text.RegularExpressions.RegexCompiler.Mvfldloc
void Mvfldloc(FieldInfo ft, LocalBuilder lt)
Definition RegexCompiler.cs:489

References System.Text.RegularExpressions.RegexCompiler._boyerMoorePrefix, System.Text.RegularExpressions.RegexCompiler._code, System.Text.RegularExpressions.RegexCompiler._int32LocalsPool, System.Text.RegularExpressions.RegexCompiler._leadingAnchor, System.Text.RegularExpressions.RegexCompiler._leadingCharClasses, System.Text.RegularExpressions.RegexCompiler._options, System.Text.RegularExpressions.RegexCompiler._readOnlySpanCharLocalsPool, System.Text.RegularExpressions.RegexCompiler._runtextbegLocal, System.Text.RegularExpressions.RegexCompiler._runtextendLocal, System.Text.RegularExpressions.RegexCompiler._runtextLocal, System.Text.RegularExpressions.RegexCompiler._runtextposLocal, System.Text.RegularExpressions.RegexCompiler._textInfoLocal, System.Text.RegularExpressions.RegexCompiler.Add(), System.Reflection.Emit.Beq, System.Text.RegularExpressions.RegexCompiler.BeqFar(), System.Reflection.Emit.Bge, System.Text.RegularExpressions.RegexCompiler.BgeFar(), System.Reflection.Emit.Bgt, System.Text.RegularExpressions.RegexCompiler.BgtFar(), System.Text.RegularExpressions.RegexCompiler.BgtUn(), System.Reflection.Emit.Ble, System.Text.RegularExpressions.RegexCompiler.BleFar(), System.Reflection.Emit.Blt, System.Text.RegularExpressions.RegexCompiler.BltFar(), System.Text.RegularExpressions.RegexCompiler.BneFar(), System.Reflection.Emit.Br, System.Text.RegularExpressions.RegexCompiler.BrfalseFar(), System.Text.RegularExpressions.RegexCompiler.BrFar(), System.Reflection.Emit.Brtrue, System.Reflection.Emit.Call, System.Text.RegularExpressions.RegexCompiler.CallToLower(), System.Text.RegularExpressions.RegexBoyerMoore.CaseInsensitive, System.Text.RegularExpressions.RegexCompiler.CharClass, System.chars, System.Collections.Generic.Stack< T >.Clear(), System.Text.RegularExpressions.RegexCompiler.DeclareInt32(), System.Text.RegularExpressions.RegexCompiler.DeclareString(), System.Text.RegularExpressions.RegexCompiler.DeclareTextInfo(), System.Text.RegularExpressions.RegexCompiler.DefineLabel(), System.Text.RegularExpressions.RegexCompiler.EmitMatchCharacterClass(), System.Text.RegularExpressions.RegexCharClass.GetSetChars(), System.Text.RegularExpressions.RegexBoyerMoore.HighASCII, System.Text.RegularExpressions.i, System.index, System.Text.RegularExpressions.RegexCompiler.InitLocalCultureInfo(), System.Text.RegularExpressions.RegexCharClass.IsNegated(), System.Text.RegularExpressions.RegexCharClass.IsSingleton(), System.Text.RegularExpressions.RegexCompiler.Ldc(), System.Text.RegularExpressions.RegexCompiler.LdindU2(), System.Reflection.Emit.Ldloc, System.Reflection.Emit.Ldloca, System.Reflection.Emit.Ldstr, System.Text.RegularExpressions.RegexCompiler.Ldthis(), System.Text.RegularExpressions.RegexCompiler.Ldthisfld(), System.Text.RegularExpressions.RegexCompiler.Leftcharnext(), System.Text.RegularExpressions.RegexBoyerMoore.LowASCII, System.Text.RegularExpressions.RegexCompiler.MarkLabel(), System.Text.RegularExpressions.RegexTree.MinRequiredLength, System.Text.RegularExpressions.RegexCompiler.Mvfldloc(), System.Text.RegularExpressions.RegexCompiler.Mvlocfld(), System.Text.RegularExpressions.RegexCompiler.Neg(), System.Text.RegularExpressions.RegexBoyerMoore.NegativeASCII, System.Text.RegularExpressions.RegexBoyerMoore.NegativeUnicode, System.Text.RegularExpressions.RegexCompiler.ParticipatesInCaseConversion(), System.Text.RegularExpressions.RegexBoyerMoore.Pattern, System.Text.RegularExpressions.RegexBoyerMoore.Positive, System.Text.RegularExpressions.RegexCompiler.RentInt32Local(), System.Text.RegularExpressions.RegexCompiler.RentReadOnlySpanCharLocal(), System.Text.RegularExpressions.RegexCompiler.Ret(), System.Text.RegularExpressions.RegexCompiler.Rightchar(), System.Text.RegularExpressions.RegexCode.RightToLeft, System.Text.RegularExpressions.RegexCompiler.s_runtextbegField, System.Text.RegularExpressions.RegexCompiler.s_runtextendField, System.Text.RegularExpressions.RegexCompiler.s_runtextField, System.Text.RegularExpressions.RegexCompiler.s_runtextposField, System.Text.RegularExpressions.RegexCompiler.s_runtextstartField, System.Text.RegularExpressions.RegexCompiler.s_spanGetItemMethod, System.Text.RegularExpressions.RegexCompiler.s_spanGetLengthMethod, System.Text.RegularExpressions.RegexCompiler.s_spanIndexOf, System.Text.RegularExpressions.RegexCompiler.s_spanIndexOfAnyCharChar, System.Text.RegularExpressions.RegexCompiler.s_spanIndexOfAnyCharCharChar, System.Text.RegularExpressions.RegexCompiler.s_spanSliceIntMethod, System.Text.RegularExpressions.RegexCompiler.s_stringAsSpanIntIntMethod, System.Text.RegularExpressions.RegexCompiler.s_stringGetCharsMethod, System.Text.RegularExpressions.RegexCompiler.s_stringIndexOfCharInt, System.Text.RegularExpressions.RegexCharClass.SingletonChar(), System.state, System.Reflection.Emit.Stfld, System.Reflection.Emit.Stloc, System.Text.RegularExpressions.str, System.Text.RegularExpressions.RegexCompiler.Sub(), and System.Text.RegularExpressions.RegexCode.Tree.

Referenced by System.Text.RegularExpressions.RegexLWCGCompiler.FactoryInstanceFromCode().