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

◆ TryGenerateNonBacktrackingGo()

bool System.Text.RegularExpressions.RegexCompiler.TryGenerateNonBacktrackingGo ( RegexNode node)
inlineprivateinherited

Definition at line 1625 of file RegexCompiler.cs.

1626 {
1627 if ((node.Options & RegexOptions.RightToLeft) != 0)
1628 {
1629 return false;
1630 }
1631 node = node.Child(0);
1632 if (!NodeSupportsNonBacktrackingImplementation(node, 20))
1633 {
1634 return false;
1635 }
1636 LocalBuilder runtextLocal = DeclareString();
1637 LocalBuilder lt = DeclareInt32();
1638 LocalBuilder runtextposLocal = DeclareInt32();
1639 LocalBuilder textSpanLocal = DeclareReadOnlySpanChar();
1640 LocalBuilder runtextendLocal = DeclareInt32();
1641 Label l = DefineLabel();
1642 Label doneLabel = DefineLabel();
1643 if (_hasTimeout)
1644 {
1645 _loopTimeoutCounterLocal = DeclareInt32();
1646 }
1647 InitializeCultureForGoIfNecessary();
1648 Mvfldloc(s_runtextField, runtextLocal);
1649 Mvfldloc(s_runtextendField, runtextendLocal);
1650 Ldthisfld(s_runtextposField);
1651 Stloc(runtextposLocal);
1652 Ldloc(runtextposLocal);
1653 Stloc(lt);
1654 int textSpanPos = 0;
1655 LoadTextSpanLocal();
1656 EmitNode(node);
1657 MarkLabel(l);
1658 Ldthis();
1659 Ldloc(runtextposLocal);
1660 if (textSpanPos > 0)
1661 {
1662 Ldc(textSpanPos);
1663 Add();
1664 Stloc(runtextposLocal);
1665 Ldloc(runtextposLocal);
1666 }
1667 Stfld(s_runtextposField);
1668 Ldthis();
1669 Ldc(0);
1670 Ldloc(lt);
1671 Ldloc(runtextposLocal);
1672 Call(s_captureMethod);
1673 if (((uint)node.Options & 0x80000000u) != 0)
1674 {
1675 Label l2 = DefineLabel();
1676 Br(l2);
1677 MarkLabel(doneLabel);
1678 Label l3 = DefineLabel();
1679 Label l4 = DefineLabel();
1680 Br(l3);
1681 MarkLabel(l4);
1682 Ldthis();
1683 Call(s_uncaptureMethod);
1684 MarkLabel(l3);
1685 Ldthis();
1686 Call(s_crawlposMethod);
1687 Brtrue(l4);
1688 MarkLabel(l2);
1689 }
1690 else
1691 {
1692 MarkLabel(doneLabel);
1693 }
1694 Ret();
1695 return true;
1696 void EmitAnchors(RegexNode node)
1697 {
1698 switch (node.Type)
1699 {
1700 default:
1701 return;
1702 case 18:
1703 case 19:
1704 if (textSpanPos > 0)
1705 {
1706 BrFar(doneLabel);
1707 }
1708 else
1709 {
1710 Ldloc(runtextposLocal);
1711 Ldthisfld((node.Type == 18) ? s_runtextbegField : s_runtextstartField);
1712 BneFar(doneLabel);
1713 }
1714 return;
1715 case 14:
1716 if (textSpanPos > 0)
1717 {
1718 Ldloca(textSpanLocal);
1719 Ldc(textSpanPos - 1);
1720 Call(s_spanGetItemMethod);
1721 LdindU2();
1722 Ldc(10);
1723 BneFar(doneLabel);
1724 }
1725 else
1726 {
1727 Label l5 = DefineLabel();
1728 Ldloc(runtextposLocal);
1729 Ldthisfld(s_runtextbegField);
1730 Ble(l5);
1731 Ldthisfld(s_runtextField);
1732 Ldloc(runtextposLocal);
1733 Ldc(1);
1734 Sub();
1735 Call(s_stringGetCharsMethod);
1736 Ldc(10);
1737 BneFar(doneLabel);
1738 MarkLabel(l5);
1739 }
1740 return;
1741 case 21:
1742 Ldc(textSpanPos);
1743 Ldloca(textSpanLocal);
1744 Call(s_spanGetLengthMethod);
1745 BltUnFar(doneLabel);
1746 return;
1747 case 20:
1748 Ldc(textSpanPos);
1749 Ldloca(textSpanLocal);
1750 Call(s_spanGetLengthMethod);
1751 Ldc(1);
1752 Sub();
1753 BltFar(doneLabel);
1754 break;
1755 case 15:
1756 break;
1757 case 16:
1758 case 17:
1759 return;
1760 }
1761 Label l6 = DefineLabel();
1762 Ldc(textSpanPos);
1763 Ldloca(textSpanLocal);
1764 Call(s_spanGetLengthMethod);
1765 BgeUn(l6);
1766 Ldloca(textSpanLocal);
1767 Ldc(textSpanPos);
1768 Call(s_spanGetItemMethod);
1769 LdindU2();
1770 Ldc(10);
1771 BneFar(doneLabel);
1772 MarkLabel(l6);
1773 }
1774 void EmitAtomicAlternate(RegexNode node)
1775 {
1776 using RentedLocalBuilder rentedLocalBuilder5 = RentInt32Local();
1777 Ldloc(runtextposLocal);
1778 Stloc(rentedLocalBuilder5);
1779 int num2 = textSpanPos;
1780 RentedLocalBuilder? rentedLocalBuilder6 = null;
1781 if (((uint)node.Options & 0x80000000u) != 0)
1782 {
1783 rentedLocalBuilder6 = RentInt32Local();
1784 Ldthis();
1785 Call(s_crawlposMethod);
1786 RentedLocalBuilder? rentedLocalBuilder7 = rentedLocalBuilder6;
1787 Stloc(rentedLocalBuilder7.HasValue ? ((LocalBuilder)rentedLocalBuilder7.GetValueOrDefault()) : null);
1788 }
1789 Label l17 = DefineLabel();
1790 Label label4 = doneLabel;
1791 int num3 = node.ChildCount();
1792 for (int j = 0; j < num3 - 1; j++)
1793 {
1794 Label l18 = (doneLabel = DefineLabel());
1795 EmitNode(node.Child(j));
1796 TransferTextSpanPosToRunTextPos();
1797 BrFar(l17);
1798 MarkLabel(l18);
1799 Ldloc(rentedLocalBuilder5);
1800 Stloc(runtextposLocal);
1801 LoadTextSpanLocal();
1802 textSpanPos = num2;
1803 if (rentedLocalBuilder6.HasValue)
1804 {
1805 RentedLocalBuilder? rentedLocalBuilder7 = rentedLocalBuilder6;
1806 EmitUncaptureUntil(rentedLocalBuilder7.HasValue ? ((LocalBuilder)rentedLocalBuilder7.GetValueOrDefault()) : null);
1807 }
1808 }
1809 if (rentedLocalBuilder6.HasValue)
1810 {
1811 Label l19 = (doneLabel = DefineLabel());
1812 EmitNode(node.Child(num3 - 1));
1813 doneLabel = label4;
1814 TransferTextSpanPosToRunTextPos();
1815 Br(l17);
1816 MarkLabel(l19);
1817 RentedLocalBuilder? rentedLocalBuilder7 = rentedLocalBuilder6;
1818 EmitUncaptureUntil(rentedLocalBuilder7.HasValue ? ((LocalBuilder)rentedLocalBuilder7.GetValueOrDefault()) : null);
1819 BrFar(doneLabel);
1820 }
1821 else
1822 {
1823 doneLabel = label4;
1824 EmitNode(node.Child(num3 - 1));
1825 TransferTextSpanPosToRunTextPos();
1826 }
1827 MarkLabel(l17);
1828 rentedLocalBuilder6?.Dispose();
1829 }
1830 void EmitAtomicNodeLoop(RegexNode node)
1831 {
1832 if (node.M == node.N)
1833 {
1834 EmitNodeRepeater(node);
1835 return;
1836 }
1837 using RentedLocalBuilder rentedLocalBuilder2 = RentInt32Local();
1838 using RentedLocalBuilder rentedLocalBuilder3 = RentInt32Local();
1839 Label label2 = doneLabel;
1840 doneLabel = DefineLabel();
1841 TransferTextSpanPosToRunTextPos();
1842 Label l10 = DefineLabel();
1843 Label l11 = DefineLabel();
1844 int m2 = node.M;
1845 int n2 = node.N;
1846 Ldc(0);
1847 Stloc(rentedLocalBuilder2);
1848 BrFar(l10);
1849 MarkLabel(l11);
1850 EmitTimeoutCheck();
1851 Label l12 = DefineLabel();
1852 Label label3 = doneLabel;
1853 doneLabel = DefineLabel();
1854 Ldloc(runtextposLocal);
1855 Stloc(rentedLocalBuilder3);
1856 EmitNode(node.Child(0));
1857 TransferTextSpanPosToRunTextPos();
1858 Br(l12);
1859 MarkLabel(doneLabel);
1860 doneLabel = label3;
1861 Ldloc(rentedLocalBuilder3);
1862 Stloc(runtextposLocal);
1863 BrFar(doneLabel);
1864 MarkLabel(l12);
1865 Ldloc(rentedLocalBuilder2);
1866 Ldc(1);
1867 Add();
1868 Stloc(rentedLocalBuilder2);
1869 MarkLabel(l10);
1870 if (n2 != int.MaxValue)
1871 {
1872 Ldloc(rentedLocalBuilder2);
1873 Ldc(n2);
1874 BltFar(l11);
1875 }
1876 else
1877 {
1878 BrFar(l11);
1879 }
1880 MarkLabel(doneLabel);
1881 doneLabel = label2;
1882 if (m2 > 0)
1883 {
1884 Ldloc(rentedLocalBuilder2);
1885 Ldc(m2);
1886 BltFar(doneLabel);
1887 }
1888 }
1889 void EmitAtomicSingleCharZeroOrOne(RegexNode node)
1890 {
1891 Label l7 = DefineLabel();
1892 Ldc(textSpanPos);
1893 Ldloca(textSpanLocal);
1894 Call(s_spanGetLengthMethod);
1895 BgeUnFar(l7);
1896 Ldloca(textSpanLocal);
1897 Ldc(textSpanPos);
1898 Call(s_spanGetItemMethod);
1899 LdindU2();
1900 switch (node.Type)
1901 {
1902 case 43:
1903 if (IsCaseInsensitive(node) && ParticipatesInCaseConversion(node.Ch))
1904 {
1905 CallToLower();
1906 }
1907 Ldc(node.Ch);
1908 BneFar(l7);
1909 break;
1910 case 44:
1911 if (IsCaseInsensitive(node) && ParticipatesInCaseConversion(node.Ch))
1912 {
1913 CallToLower();
1914 }
1915 Ldc(node.Ch);
1916 BeqFar(l7);
1917 break;
1918 case 45:
1919 EmitMatchCharacterClass(node.Str, IsCaseInsensitive(node));
1920 BrfalseFar(l7);
1921 break;
1922 }
1923 Ldloca(textSpanLocal);
1924 Ldc(1);
1925 Call(s_spanSliceIntMethod);
1926 Stloc(textSpanLocal);
1927 Ldloc(runtextposLocal);
1928 Ldc(1);
1929 Add();
1930 Stloc(runtextposLocal);
1931 MarkLabel(l7);
1932 }
1933 void EmitBoundary(RegexNode node)
1934 {
1935 Ldthis();
1936 Ldloc(runtextposLocal);
1937 if (textSpanPos > 0)
1938 {
1939 Ldc(textSpanPos);
1940 Add();
1941 }
1942 Ldthisfld(s_runtextbegField);
1943 Ldloc(runtextendLocal);
1944 switch (node.Type)
1945 {
1946 case 16:
1947 Call(s_isBoundaryMethod);
1948 BrfalseFar(doneLabel);
1949 break;
1950 case 17:
1951 Call(s_isBoundaryMethod);
1952 BrtrueFar(doneLabel);
1953 break;
1954 case 41:
1955 Call(s_isECMABoundaryMethod);
1956 BrfalseFar(doneLabel);
1957 break;
1958 default:
1959 Call(s_isECMABoundaryMethod);
1960 BrtrueFar(doneLabel);
1961 break;
1962 }
1963 }
1964 void EmitCapture(RegexNode node)
1965 {
1966 using RentedLocalBuilder rentedLocalBuilder10 = RentInt32Local();
1967 int num5 = node.M;
1968 if (num5 != -1 && _code.Caps != null)
1969 {
1970 num5 = (int)_code.Caps[num5];
1971 }
1972 TransferTextSpanPosToRunTextPos();
1973 Ldloc(runtextposLocal);
1974 Stloc(rentedLocalBuilder10);
1975 EmitNode(node.Child(0));
1976 TransferTextSpanPosToRunTextPos();
1977 Ldthis();
1978 Ldc(num5);
1979 Ldloc(rentedLocalBuilder10);
1980 Ldloc(runtextposLocal);
1981 Call(s_captureMethod);
1982 }
1983 void EmitMultiChar(RegexNode node)
1984 {
1985 bool flag = IsCaseInsensitive(node);
1986 if (!flag && node.Str.Length > 64)
1987 {
1988 Ldloca(textSpanLocal);
1989 Ldc(textSpanPos);
1990 Call(s_spanSliceIntMethod);
1991 Ldstr(node.Str);
1992 Call(s_stringAsSpanMethod);
1993 Call(s_spanStartsWith);
1994 BrfalseFar(doneLabel);
1995 textSpanPos += node.Str.Length;
1996 }
1997 else
1998 {
1999 ReadOnlySpan<char> span = node.Str;
2000 EmitSpanLengthCheck(span.Length);
2001 if (!flag && !_persistsAssembly)
2002 {
2003 if (IntPtr.Size == 8)
2004 {
2005 while (span.Length >= 4)
2006 {
2007 EmitTextSpanOffset();
2008 Unaligned(1);
2009 LdindI8();
2010 LdcI8(MemoryMarshal.Read<long>(MemoryMarshal.AsBytes(span)));
2011 BneFar(doneLabel);
2012 textSpanPos += 4;
2013 span = span.Slice(4);
2014 }
2015 }
2016 while (span.Length >= 2)
2017 {
2018 EmitTextSpanOffset();
2019 Unaligned(1);
2020 LdindI4();
2021 Ldc(MemoryMarshal.Read<int>(MemoryMarshal.AsBytes(span)));
2022 BneFar(doneLabel);
2023 textSpanPos += 2;
2024 span = span.Slice(2);
2025 }
2026 }
2027 for (int i = 0; i < span.Length; i++)
2028 {
2029 EmitTextSpanOffset();
2030 textSpanPos++;
2031 LdindU2();
2032 if (flag && ParticipatesInCaseConversion(span[i]))
2033 {
2034 CallToLower();
2035 }
2036 Ldc(span[i]);
2037 BneFar(doneLabel);
2038 }
2039 }
2040 }
2041 void EmitNegativeLookaheadAssertion(RegexNode node)
2042 {
2043 using RentedLocalBuilder rentedLocalBuilder12 = RentInt32Local();
2044 Ldloc(runtextposLocal);
2045 Stloc(rentedLocalBuilder12);
2046 int num7 = textSpanPos;
2047 Label label5 = doneLabel;
2048 doneLabel = DefineLabel();
2049 EmitNode(node.Child(0));
2050 BrFar(label5);
2051 MarkLabel(doneLabel);
2052 doneLabel = label5;
2053 Ldloc(rentedLocalBuilder12);
2054 Stloc(runtextposLocal);
2055 LoadTextSpanLocal();
2056 textSpanPos = num7;
2057 }
2058 void EmitNode(RegexNode node)
2059 {
2060 switch (node.Type)
2061 {
2062 case 9:
2063 case 10:
2064 case 11:
2065 EmitSingleChar(node);
2066 break;
2067 case 16:
2068 case 17:
2069 case 41:
2070 case 42:
2071 EmitBoundary(node);
2072 break;
2073 case 14:
2074 case 15:
2075 case 18:
2076 case 19:
2077 case 20:
2078 case 21:
2079 EmitAnchors(node);
2080 break;
2081 case 12:
2082 EmitMultiChar(node);
2083 break;
2084 case 43:
2085 case 44:
2086 case 45:
2087 EmitSingleCharAtomicLoop(node);
2088 break;
2089 case 26:
2090 EmitAtomicNodeLoop(node);
2091 break;
2092 case 27:
2093 if (node.M > 0)
2094 {
2095 EmitNodeRepeater(node);
2096 }
2097 break;
2098 case 32:
2099 EmitNode(node.Child(0));
2100 break;
2101 case 24:
2102 EmitAtomicAlternate(node);
2103 break;
2104 case 3:
2105 case 4:
2106 case 5:
2107 case 6:
2108 case 7:
2109 case 8:
2110 EmitSingleCharRepeater(node);
2111 break;
2112 case 25:
2113 {
2114 int num8 = node.ChildCount();
2115 for (int num9 = 0; num9 < num8; num9++)
2116 {
2117 EmitNode(node.Child(num9));
2118 }
2119 break;
2120 }
2121 case 28:
2122 EmitCapture(node);
2123 break;
2124 case 30:
2125 EmitPositiveLookaheadAssertion(node);
2126 break;
2127 case 31:
2128 EmitNegativeLookaheadAssertion(node);
2129 break;
2130 case 22:
2131 BrFar(doneLabel);
2132 break;
2133 case 46:
2134 EmitUpdateBumpalong();
2135 break;
2136 case 13:
2137 case 23:
2138 case 29:
2139 case 33:
2140 case 34:
2141 case 35:
2142 case 36:
2143 case 37:
2144 case 38:
2145 case 39:
2146 case 40:
2147 break;
2148 }
2149 }
2150 void EmitNodeRepeater(RegexNode node)
2151 {
2152 int m3 = node.M;
2153 if (m3 == 1)
2154 {
2155 EmitNode(node.Child(0));
2156 return;
2157 }
2158 TransferTextSpanPosToRunTextPos();
2159 Label l13 = DefineLabel();
2160 Label l14 = DefineLabel();
2161 using RentedLocalBuilder rentedLocalBuilder4 = RentInt32Local();
2162 Ldc(0);
2163 Stloc(rentedLocalBuilder4);
2164 BrFar(l13);
2165 MarkLabel(l14);
2166 EmitTimeoutCheck();
2167 EmitNode(node.Child(0));
2168 TransferTextSpanPosToRunTextPos();
2169 Ldloc(rentedLocalBuilder4);
2170 Ldc(1);
2171 Add();
2172 Stloc(rentedLocalBuilder4);
2173 MarkLabel(l13);
2174 Ldloc(rentedLocalBuilder4);
2175 Ldc(m3);
2176 BltFar(l14);
2177 }
2178 void EmitPositiveLookaheadAssertion(RegexNode node)
2179 {
2180 using RentedLocalBuilder rentedLocalBuilder11 = RentInt32Local();
2181 Ldloc(runtextposLocal);
2182 Stloc(rentedLocalBuilder11);
2183 int num6 = textSpanPos;
2184 EmitNode(node.Child(0));
2185 Ldloc(rentedLocalBuilder11);
2186 Stloc(runtextposLocal);
2187 LoadTextSpanLocal();
2188 textSpanPos = num6;
2189 }
2190 void EmitSingleChar(RegexNode node, bool emitLengthCheck = true, LocalBuilder offset = null)
2191 {
2192 if (emitLengthCheck)
2193 {
2194 EmitSpanLengthCheck(1, offset);
2195 }
2196 Ldloca(textSpanLocal);
2197 EmitSum(textSpanPos, offset);
2198 Call(s_spanGetItemMethod);
2199 LdindU2();
2200 switch (node.Type)
2201 {
2202 case 5:
2203 case 8:
2204 case 11:
2205 case 45:
2206 EmitMatchCharacterClass(node.Str, IsCaseInsensitive(node));
2207 BrfalseFar(doneLabel);
2208 break;
2209 case 3:
2210 case 6:
2211 case 9:
2212 case 43:
2213 if (IsCaseInsensitive(node) && ParticipatesInCaseConversion(node.Ch))
2214 {
2215 CallToLower();
2216 }
2217 Ldc(node.Ch);
2218 BneFar(doneLabel);
2219 break;
2220 default:
2221 if (IsCaseInsensitive(node) && ParticipatesInCaseConversion(node.Ch))
2222 {
2223 CallToLower();
2224 }
2225 Ldc(node.Ch);
2226 BeqFar(doneLabel);
2227 break;
2228 }
2229 textSpanPos++;
2230 }
2231 void EmitSingleCharAtomicLoop(RegexNode node)
2232 {
2233 if (node.M == node.N)
2234 {
2235 EmitSingleCharRepeater(node);
2236 }
2237 else
2238 {
2239 if (node.M != 0 || node.N != 1)
2240 {
2241 int m = node.M;
2242 int n = node.N;
2243 using RentedLocalBuilder rentedLocalBuilder = RentInt32Local();
2244 Label label = doneLabel;
2245 doneLabel = DefineLabel();
2246 Span<char> chars = stackalloc char[3];
2247 int num = 0;
2248 if (node.Type == 44 && n == int.MaxValue && (!IsCaseInsensitive(node) || !ParticipatesInCaseConversion(node.Ch)))
2249 {
2250 if (textSpanPos > 0)
2251 {
2252 Ldloca(textSpanLocal);
2253 Ldc(textSpanPos);
2254 Call(s_spanSliceIntMethod);
2255 }
2256 else
2257 {
2258 Ldloc(textSpanLocal);
2259 }
2260 Ldc(node.Ch);
2261 Call(s_spanIndexOf);
2262 Stloc(rentedLocalBuilder);
2263 Ldloc(rentedLocalBuilder);
2264 Ldc(-1);
2265 BneFar(doneLabel);
2266 Ldloca(textSpanLocal);
2267 Call(s_spanGetLengthMethod);
2268 if (textSpanPos > 0)
2269 {
2270 Ldc(textSpanPos);
2271 Sub();
2272 }
2273 Stloc(rentedLocalBuilder);
2274 }
2275 else if (node.Type == 45 && n == int.MaxValue && !IsCaseInsensitive(node) && (num = RegexCharClass.GetSetChars(node.Str, chars)) > 1 && RegexCharClass.IsNegated(node.Str))
2276 {
2277 if (textSpanPos > 0)
2278 {
2279 Ldloca(textSpanLocal);
2280 Ldc(textSpanPos);
2281 Call(s_spanSliceIntMethod);
2282 }
2283 else
2284 {
2285 Ldloc(textSpanLocal);
2286 }
2287 Ldc(chars[0]);
2288 Ldc(chars[1]);
2289 if (num == 2)
2290 {
2291 Call(s_spanIndexOfAnyCharChar);
2292 }
2293 else
2294 {
2295 Ldc(chars[2]);
2296 Call(s_spanIndexOfAnyCharCharChar);
2297 }
2298 Stloc(rentedLocalBuilder);
2299 Ldloc(rentedLocalBuilder);
2300 Ldc(-1);
2301 BneFar(doneLabel);
2302 Ldloca(textSpanLocal);
2303 Call(s_spanGetLengthMethod);
2304 if (textSpanPos > 0)
2305 {
2306 Ldc(textSpanPos);
2307 Sub();
2308 }
2309 Stloc(rentedLocalBuilder);
2310 }
2311 else if (node.Type == 45 && n == int.MaxValue && node.Str == "\0\u0001\0\0")
2312 {
2313 TransferTextSpanPosToRunTextPos();
2314 Ldloc(runtextendLocal);
2315 Ldloc(runtextposLocal);
2316 Sub();
2317 Stloc(rentedLocalBuilder);
2318 }
2319 else
2320 {
2321 TransferTextSpanPosToRunTextPos();
2322 Label l8 = DefineLabel();
2323 Label l9 = DefineLabel();
2324 Ldc(0);
2325 Stloc(rentedLocalBuilder);
2326 BrFar(l8);
2327 MarkLabel(l9);
2328 EmitTimeoutCheck();
2329 Ldloc(rentedLocalBuilder);
2330 Ldloca(textSpanLocal);
2331 Call(s_spanGetLengthMethod);
2332 BgeUnFar(doneLabel);
2333 Ldloca(textSpanLocal);
2334 Ldloc(rentedLocalBuilder);
2335 Call(s_spanGetItemMethod);
2336 LdindU2();
2337 switch (node.Type)
2338 {
2339 case 43:
2340 if (IsCaseInsensitive(node) && ParticipatesInCaseConversion(node.Ch))
2341 {
2342 CallToLower();
2343 }
2344 Ldc(node.Ch);
2345 BneFar(doneLabel);
2346 break;
2347 case 44:
2348 if (IsCaseInsensitive(node) && ParticipatesInCaseConversion(node.Ch))
2349 {
2350 CallToLower();
2351 }
2352 Ldc(node.Ch);
2353 BeqFar(doneLabel);
2354 break;
2355 case 45:
2356 EmitMatchCharacterClass(node.Str, IsCaseInsensitive(node));
2357 BrfalseFar(doneLabel);
2358 break;
2359 }
2360 Ldloc(rentedLocalBuilder);
2361 Ldc(1);
2362 Add();
2363 Stloc(rentedLocalBuilder);
2364 MarkLabel(l8);
2365 if (n != int.MaxValue)
2366 {
2367 Ldloc(rentedLocalBuilder);
2368 Ldc(n);
2369 BltFar(l9);
2370 }
2371 else
2372 {
2373 BrFar(l9);
2374 }
2375 }
2376 MarkLabel(doneLabel);
2377 doneLabel = label;
2378 if (m > 0)
2379 {
2380 Ldloc(rentedLocalBuilder);
2381 Ldc(m);
2382 BltFar(doneLabel);
2383 }
2384 Ldloca(textSpanLocal);
2385 Ldloc(rentedLocalBuilder);
2386 Call(s_spanSliceIntMethod);
2387 Stloc(textSpanLocal);
2388 Ldloc(runtextposLocal);
2389 Ldloc(rentedLocalBuilder);
2390 Add();
2391 Stloc(runtextposLocal);
2392 return;
2393 }
2394 EmitAtomicSingleCharZeroOrOne(node);
2395 }
2396 }
2397 void EmitSingleCharRepeater(RegexNode node)
2398 {
2399 int m4 = node.M;
2400 if (m4 != 0)
2401 {
2402 EmitSpanLengthCheck(m4);
2403 if (m4 > 16)
2404 {
2405 Label l20 = DefineLabel();
2406 Label l21 = DefineLabel();
2407 using RentedLocalBuilder rentedLocalBuilder8 = RentReadOnlySpanCharLocal();
2408 Ldloca(textSpanLocal);
2409 Ldc(textSpanPos);
2410 Ldc(m4);
2411 Call(s_spanSliceIntIntMethod);
2412 Stloc(rentedLocalBuilder8);
2413 using RentedLocalBuilder rentedLocalBuilder9 = RentInt32Local();
2414 Ldc(0);
2415 Stloc(rentedLocalBuilder9);
2416 BrFar(l20);
2417 MarkLabel(l21);
2418 EmitTimeoutCheck();
2419 LocalBuilder localBuilder = textSpanLocal;
2420 int num4 = textSpanPos;
2421 textSpanLocal = rentedLocalBuilder8;
2422 textSpanPos = 0;
2423 EmitSingleChar(node, emitLengthCheck: false, rentedLocalBuilder9);
2424 textSpanLocal = localBuilder;
2425 textSpanPos = num4;
2426 Ldloc(rentedLocalBuilder9);
2427 Ldc(1);
2428 Add();
2429 Stloc(rentedLocalBuilder9);
2430 MarkLabel(l20);
2431 Ldloc(rentedLocalBuilder9);
2432 Ldloca(rentedLocalBuilder8);
2433 Call(s_spanGetLengthMethod);
2434 BltFar(l21);
2435 textSpanPos += m4;
2436 return;
2437 }
2438 for (int k = 0; k < m4; k++)
2439 {
2440 EmitSingleChar(node, emitLengthCheck: false);
2441 }
2442 }
2443 }
2444 void EmitSpanLengthCheck(int requiredLength, LocalBuilder dynamicRequiredLength = null)
2445 {
2446 EmitSum(textSpanPos + requiredLength - 1, dynamicRequiredLength);
2447 Ldloca(textSpanLocal);
2448 Call(s_spanGetLengthMethod);
2449 BgeUnFar(doneLabel);
2450 }
2451 void EmitSum(int constant, LocalBuilder local)
2452 {
2453 if (local == null)
2454 {
2455 Ldc(constant);
2456 }
2457 else if (constant == 0)
2458 {
2459 Ldloc(local);
2460 }
2461 else
2462 {
2463 Ldloc(local);
2464 Ldc(constant);
2465 Add();
2466 }
2467 }
2468 void EmitTextSpanOffset()
2469 {
2470 Ldloc(textSpanLocal);
2471 Call(s_memoryMarshalGetReference);
2472 if (textSpanPos > 0)
2473 {
2474 Ldc(textSpanPos * 2);
2475 Add();
2476 }
2477 }
2478 void EmitUncaptureUntil(LocalBuilder startingCrawlpos)
2479 {
2480 Label l15 = DefineLabel();
2481 Label l16 = DefineLabel();
2482 Br(l15);
2483 MarkLabel(l16);
2484 Ldthis();
2485 Call(s_uncaptureMethod);
2486 MarkLabel(l15);
2487 Ldthis();
2488 Call(s_crawlposMethod);
2489 Ldloc(startingCrawlpos);
2490 Bne(l16);
2491 }
2492 void EmitUpdateBumpalong()
2493 {
2494 TransferTextSpanPosToRunTextPos();
2495 Ldthis();
2496 Ldloc(runtextposLocal);
2497 Stfld(s_runtextposField);
2498 }
2499 static bool IsCaseInsensitive(RegexNode node)
2500 {
2501 return (node.Options & RegexOptions.IgnoreCase) != 0;
2502 }
2503 void LoadTextSpanLocal()
2504 {
2505 Ldloc(runtextLocal);
2506 Ldloc(runtextposLocal);
2507 Ldloc(runtextendLocal);
2508 Ldloc(runtextposLocal);
2509 Sub();
2510 Call(s_stringAsSpanIntIntMethod);
2511 Stloc(textSpanLocal);
2512 }
2513 static bool NodeSupportsNonBacktrackingImplementation(RegexNode node, int maxDepth)
2514 {
2515 bool flag2 = false;
2516 if ((node.Options & RegexOptions.RightToLeft) == 0 && maxDepth > 0)
2517 {
2518 int num10 = node.ChildCount();
2519 switch (node.Type)
2520 {
2521 case 9:
2522 case 10:
2523 case 11:
2524 case 12:
2525 case 14:
2526 case 15:
2527 case 16:
2528 case 17:
2529 case 18:
2530 case 19:
2531 case 20:
2532 case 21:
2533 case 22:
2534 case 23:
2535 case 41:
2536 case 42:
2537 case 43:
2538 case 44:
2539 case 45:
2540 case 46:
2541 flag2 = true;
2542 break;
2543 case 3:
2544 case 4:
2545 case 5:
2546 case 6:
2547 case 7:
2548 case 8:
2549 flag2 = node.M == node.N || (node.Next != null && node.Next.Type == 32);
2550 break;
2551 case 26:
2552 case 27:
2553 flag2 = (node.M == node.N || (node.Next != null && node.Next.Type == 32)) && NodeSupportsNonBacktrackingImplementation(node.Child(0), maxDepth - 1);
2554 break;
2555 case 30:
2556 case 31:
2557 case 32:
2558 flag2 = NodeSupportsNonBacktrackingImplementation(node.Child(0), maxDepth - 1);
2559 break;
2560 case 24:
2561 if (node.Next == null || (!node.IsAtomicByParent() && (node.Next.Type != 28 || node.Next.Next != null)))
2562 {
2563 break;
2564 }
2565 goto case 25;
2566 case 25:
2567 {
2568 flag2 = true;
2569 for (int num11 = 0; num11 < num10; num11++)
2570 {
2571 if (flag2 && !NodeSupportsNonBacktrackingImplementation(node.Child(num11), maxDepth - 1))
2572 {
2573 flag2 = false;
2574 break;
2575 }
2576 }
2577 break;
2578 }
2579 case 28:
2580 flag2 = node.N == -1;
2581 if (flag2)
2582 {
2583 RegexNode regexNode = node.Next;
2584 while (regexNode != null)
2585 {
2586 switch (regexNode.Type)
2587 {
2588 case 24:
2589 case 25:
2590 case 28:
2591 case 30:
2592 case 32:
2593 regexNode = regexNode.Next;
2594 break;
2595 default:
2596 regexNode = null;
2597 flag2 = false;
2598 break;
2599 }
2600 }
2601 if (flag2)
2602 {
2603 flag2 = NodeSupportsNonBacktrackingImplementation(node.Child(0), maxDepth - 1);
2604 if (flag2)
2605 {
2606 regexNode = node;
2607 while (regexNode != null && (regexNode.Options & (RegexOptions)(-2147483648)) == 0)
2608 {
2609 regexNode.Options |= (RegexOptions)(-2147483648);
2610 regexNode = regexNode.Next;
2611 }
2612 }
2613 }
2614 }
2615 break;
2616 }
2617 }
2618 return flag2;
2619 }
2620 void TransferTextSpanPosToRunTextPos()
2621 {
2622 if (textSpanPos > 0)
2623 {
2624 Ldloc(runtextposLocal);
2625 Ldc(textSpanPos);
2626 Add();
2627 Stloc(runtextposLocal);
2628 Ldloca(textSpanLocal);
2629 Ldc(textSpanPos);
2630 Call(s_spanSliceIntMethod);
2631 Stloc(textSpanLocal);
2632 textSpanPos = 0;
2633 }
2634 }
2635 }
System.Text.RegularExpressions.RegexCompiler.s_memoryMarshalGetReference
static readonly MethodInfo s_memoryMarshalGetReference
Definition RegexCompiler.cs:113
System.Text.RegularExpressions.RegexCompiler.s_stringAsSpanMethod
static readonly MethodInfo s_stringAsSpanMethod
Definition RegexCompiler.cs:150
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_isECMABoundaryMethod
static readonly MethodInfo s_isECMABoundaryMethod
Definition RegexCompiler.cs:89
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.s_stringGetCharsMethod
static readonly MethodInfo s_stringGetCharsMethod
Definition RegexCompiler.cs:159
System.Text.RegularExpressions.RegexCompiler.s_spanGetItemMethod
static readonly MethodInfo s_spanGetItemMethod
Definition RegexCompiler.cs:109
System.Text.RegularExpressions.RegexCompiler.s_uncaptureMethod
static readonly MethodInfo s_uncaptureMethod
Definition RegexCompiler.cs:79
System.Text.RegularExpressions.RegexCompiler.s_crawlposMethod
static readonly MethodInfo s_crawlposMethod
Definition RegexCompiler.cs:91
System.Text.RegularExpressions.RegexCompiler.s_spanSliceIntIntMethod
static readonly MethodInfo s_spanSliceIntIntMethod
Definition RegexCompiler.cs:138
System.Text.RegularExpressions.RegexCompiler.ParticipatesInCaseConversion
static bool ParticipatesInCaseConversion(int comparison)
Definition RegexCompiler.cs:929
System.Text.RegularExpressions.RegexCompiler.s_spanStartsWith
static readonly MethodInfo s_spanStartsWith
Definition RegexCompiler.cs:144
System.Text.RegularExpressions.RegexCompiler.s_spanIndexOfAnyCharCharChar
static readonly MethodInfo s_spanIndexOfAnyCharCharChar
Definition RegexCompiler.cs:128
System.Text.RegularExpressions.RegexCompiler.s_captureMethod
static readonly MethodInfo s_captureMethod
Definition RegexCompiler.cs:75
System.Text.RegularExpressions.RegexCompiler.s_runtextbegField
static readonly FieldInfo s_runtextbegField
Definition RegexCompiler.cs:51
System.Text.RegularExpressions.RegexCompiler.s_isBoundaryMethod
static readonly MethodInfo s_isBoundaryMethod
Definition RegexCompiler.cs:87
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._code, System.Text.RegularExpressions.RegexCompiler._hasTimeout, System.Text.RegularExpressions.RegexCompiler._loopTimeoutCounterLocal, System.Text.RegularExpressions.RegexCompiler._persistsAssembly, System.Text.RegularExpressions.RegexCompiler.Add(), System.Text.RegularExpressions.RegexCompiler.BeqFar(), System.Text.RegularExpressions.RegexCompiler.BgeUn(), System.Text.RegularExpressions.RegexCompiler.BgeUnFar(), System.Reflection.Emit.Ble, System.Text.RegularExpressions.RegexCompiler.BltFar(), System.Text.RegularExpressions.RegexCompiler.BltUnFar(), System.Text.RegularExpressions.RegexCompiler.Bne(), System.Text.RegularExpressions.RegexCompiler.BneFar(), System.Reflection.Emit.Br, System.Text.RegularExpressions.RegexCompiler.BrfalseFar(), System.Text.RegularExpressions.RegexCompiler.BrFar(), System.Reflection.Emit.Brtrue, System.Text.RegularExpressions.RegexCompiler.BrtrueFar(), System.Reflection.Emit.Call, System.Text.RegularExpressions.RegexCompiler.CallToLower(), System.Text.RegularExpressions.RegexCode.Caps, System.chars, System.Text.RegularExpressions.RegexCompiler.DeclareInt32(), System.Text.RegularExpressions.RegexCompiler.DeclareReadOnlySpanChar(), System.Text.RegularExpressions.RegexCompiler.DeclareString(), System.Text.RegularExpressions.RegexCompiler.DefineLabel(), System.Text.RegularExpressions.RegexCompiler.EmitMatchCharacterClass(), System.Text.RegularExpressions.RegexCompiler.EmitTimeoutCheck(), System.Text.RegularExpressions.RegexCharClass.GetSetChars(), System.Text.RegularExpressions.i, System.Text.RegularExpressions.RegexCompiler.InitializeCultureForGoIfNecessary(), System.Text.RegularExpressions.RegexCompiler.IsCaseInsensitive(), System.Text.RegularExpressions.RegexCharClass.IsNegated(), System.Text.RegularExpressions.RegexCompiler.Ldc(), System.Text.RegularExpressions.RegexCompiler.LdcI8(), System.Text.RegularExpressions.RegexCompiler.LdindI4(), System.Text.RegularExpressions.RegexCompiler.LdindI8(), 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.MarkLabel(), System.Reflection.MaxValue, System.Text.RegularExpressions.RegexCompiler.Mvfldloc(), System.offset, System.Text.RegularExpressions.RegexCompiler.ParticipatesInCaseConversion(), System.Text.RegularExpressions.RegexCompiler.RentInt32Local(), System.Text.RegularExpressions.RegexCompiler.RentReadOnlySpanCharLocal(), System.Text.RegularExpressions.RegexCompiler.Ret(), System.Text.RegularExpressions.RegexCompiler.s_captureMethod, System.Text.RegularExpressions.RegexCompiler.s_crawlposMethod, System.Text.RegularExpressions.RegexCompiler.s_isBoundaryMethod, System.Text.RegularExpressions.RegexCompiler.s_isECMABoundaryMethod, System.Text.RegularExpressions.RegexCompiler.s_memoryMarshalGetReference, 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_spanSliceIntIntMethod, System.Text.RegularExpressions.RegexCompiler.s_spanSliceIntMethod, System.Text.RegularExpressions.RegexCompiler.s_spanStartsWith, System.Text.RegularExpressions.RegexCompiler.s_stringAsSpanIntIntMethod, System.Text.RegularExpressions.RegexCompiler.s_stringAsSpanMethod, System.Text.RegularExpressions.RegexCompiler.s_stringGetCharsMethod, System.Text.RegularExpressions.RegexCompiler.s_uncaptureMethod, System.IntPtr.Size, System.Reflection.Emit.Stfld, System.Reflection.Emit.Stloc, System.Text.RegularExpressions.RegexCompiler.Sub(), and System.Text.RegularExpressions.RegexCompiler.Unaligned().

Referenced by System.Text.RegularExpressions.RegexCompiler.GenerateGo().