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

◆ GenerateOneCode()

void System.Text.RegularExpressions.RegexCompiler.GenerateOneCode ( )
inlineprivateinherited

Definition at line 2692 of file RegexCompiler.cs.

2693 {
2694 if (_hasTimeout)
2695 {
2696 Ldthis();
2697 Call(s_checkTimeoutMethod);
2698 }
2699 switch (_regexopcode)
2700 {
2701 case 40:
2702 Mvlocfld(_runtextposLocal, s_runtextposField);
2703 Ret();
2704 break;
2705 case 22:
2706 Back();
2707 break;
2708 case 46:
2709 Ldloc(_runtrackLocal);
2710 Dup();
2711 Ldlen();
2712 Ldc(1);
2713 Sub();
2714 Ldloc(_runtextposLocal);
2715 StelemI4();
2716 break;
2717 case 38:
2718 Goto(Operand(0));
2719 break;
2720 case 37:
2721 Ldthis();
2722 Ldc(Operand(0));
2723 Call(s_isMatchedMethod);
2724 BrfalseFar(_backtrack);
2725 break;
2726 case 23:
2727 PushTrack(_runtextposLocal);
2728 Track();
2729 break;
2730 case 151:
2731 PopTrack();
2732 Stloc(_runtextposLocal);
2733 Goto(Operand(0));
2734 break;
2735 case 30:
2736 ReadyPushStack();
2737 Ldc(-1);
2738 DoPush();
2739 TrackUnique(0);
2740 break;
2741 case 31:
2742 PushStack(_runtextposLocal);
2743 TrackUnique(0);
2744 break;
2745 case 158:
2746 case 159:
2747 PopDiscardStack();
2748 Back();
2749 break;
2750 case 33:
2751 ReadyPushTrack();
2752 PopStack();
2753 Stloc(_runtextposLocal);
2754 Ldloc(_runtextposLocal);
2755 DoPush();
2756 Track();
2757 break;
2758 case 161:
2759 ReadyPushStack();
2760 PopTrack();
2761 DoPush();
2762 Back();
2763 break;
2764 case 32:
2765 {
2766 if (Operand(1) != -1)
2767 {
2768 Ldthis();
2769 Ldc(Operand(1));
2770 Call(s_isMatchedMethod);
2771 BrfalseFar(_backtrack);
2772 }
2773 using (RentedLocalBuilder rentedLocalBuilder20 = RentInt32Local())
2774 {
2775 PopStack();
2776 Stloc(rentedLocalBuilder20);
2777 if (Operand(1) != -1)
2778 {
2779 Ldthis();
2780 Ldc(Operand(0));
2781 Ldc(Operand(1));
2782 Ldloc(rentedLocalBuilder20);
2783 Ldloc(_runtextposLocal);
2784 Call(s_transferCaptureMethod);
2785 }
2786 else
2787 {
2788 Ldthis();
2789 Ldc(Operand(0));
2790 Ldloc(rentedLocalBuilder20);
2791 Ldloc(_runtextposLocal);
2792 Call(s_captureMethod);
2793 }
2794 PushTrack(rentedLocalBuilder20);
2795 }
2796 TrackUnique((Operand(0) != -1 && Operand(1) != -1) ? 4 : 3);
2797 break;
2798 }
2799 case 160:
2800 ReadyPushStack();
2801 PopTrack();
2802 DoPush();
2803 Ldthis();
2804 Call(s_uncaptureMethod);
2805 if (Operand(0) != -1 && Operand(1) != -1)
2806 {
2807 Ldthis();
2808 Call(s_uncaptureMethod);
2809 }
2810 Back();
2811 break;
2812 case 24:
2813 {
2814 Label l19 = DefineLabel();
2815 PopStack();
2816 using (RentedLocalBuilder rentedLocalBuilder18 = RentInt32Local())
2817 {
2818 Stloc(rentedLocalBuilder18);
2819 PushTrack(rentedLocalBuilder18);
2820 Ldloc(rentedLocalBuilder18);
2821 }
2822 Ldloc(_runtextposLocal);
2823 Beq(l19);
2824 PushTrack(_runtextposLocal);
2825 PushStack(_runtextposLocal);
2826 Track();
2827 Goto(Operand(0));
2828 MarkLabel(l19);
2829 TrackUnique2(5);
2830 break;
2831 }
2832 case 152:
2833 PopTrack();
2834 Stloc(_runtextposLocal);
2835 PopStack();
2836 Pop();
2837 TrackUnique2(5);
2838 Advance();
2839 break;
2840 case 280:
2841 ReadyPushStack();
2842 PopTrack();
2843 DoPush();
2844 Back();
2845 break;
2846 case 25:
2847 {
2848 using (RentedLocalBuilder rentedLocalBuilder17 = RentInt32Local())
2849 {
2850 PopStack();
2851 Stloc(rentedLocalBuilder17);
2852 Label l16 = DefineLabel();
2853 Label l17 = DefineLabel();
2854 Ldloc(rentedLocalBuilder17);
2855 Ldc(-1);
2856 Beq(l16);
2857 PushTrack(rentedLocalBuilder17);
2858 Br(l17);
2859 MarkLabel(l16);
2860 PushTrack(_runtextposLocal);
2861 MarkLabel(l17);
2862 Label l18 = DefineLabel();
2863 Ldloc(_runtextposLocal);
2864 Ldloc(rentedLocalBuilder17);
2865 Beq(l18);
2866 PushTrack(_runtextposLocal);
2867 Track();
2868 Br(AdvanceLabel());
2869 MarkLabel(l18);
2870 ReadyPushStack();
2871 Ldloc(rentedLocalBuilder17);
2872 }
2873 DoPush();
2874 TrackUnique2(6);
2875 break;
2876 }
2877 case 153:
2878 PopTrack();
2879 Stloc(_runtextposLocal);
2880 PushStack(_runtextposLocal);
2881 TrackUnique2(6);
2882 Goto(Operand(0));
2883 break;
2884 case 281:
2885 ReadyReplaceStack(0);
2886 PopTrack();
2887 DoReplace();
2888 Back();
2889 break;
2890 case 26:
2891 ReadyPushStack();
2892 Ldc(-1);
2893 DoPush();
2894 ReadyPushStack();
2895 Ldc(Operand(0));
2896 DoPush();
2897 TrackUnique(1);
2898 break;
2899 case 27:
2900 PushStack(_runtextposLocal);
2901 ReadyPushStack();
2902 Ldc(Operand(0));
2903 DoPush();
2904 TrackUnique(1);
2905 break;
2906 case 154:
2907 case 155:
2908 PopDiscardStack(2);
2909 Back();
2910 break;
2911 case 28:
2912 {
2913 using (RentedLocalBuilder rentedLocalBuilder15 = RentInt32Local())
2914 {
2915 PopStack();
2916 Stloc(rentedLocalBuilder15);
2917 PopStack();
2918 using (RentedLocalBuilder rentedLocalBuilder16 = RentInt32Local())
2919 {
2920 Stloc(rentedLocalBuilder16);
2921 PushTrack(rentedLocalBuilder16);
2922 Ldloc(rentedLocalBuilder16);
2923 }
2924 Label l14 = DefineLabel();
2925 Label l15 = DefineLabel();
2926 Ldloc(_runtextposLocal);
2927 Bne(l14);
2928 Ldloc(rentedLocalBuilder15);
2929 Ldc(0);
2930 Bge(l15);
2931 MarkLabel(l14);
2932 Ldloc(rentedLocalBuilder15);
2933 Ldc(Operand(1));
2934 Bge(l15);
2935 PushStack(_runtextposLocal);
2936 ReadyPushStack();
2937 Ldloc(rentedLocalBuilder15);
2938 Ldc(1);
2939 Add();
2940 DoPush();
2941 Track();
2942 Goto(Operand(0));
2943 MarkLabel(l15);
2944 PushTrack(rentedLocalBuilder15);
2945 }
2946 TrackUnique2(7);
2947 break;
2948 }
2949 case 156:
2950 {
2951 using (RentedLocalBuilder rentedLocalBuilder11 = RentInt32Local())
2952 {
2953 Label l12 = DefineLabel();
2954 PopStack();
2955 Ldc(1);
2956 Sub();
2957 Stloc(rentedLocalBuilder11);
2958 Ldloc(rentedLocalBuilder11);
2959 Ldc(0);
2960 Blt(l12);
2961 PopStack();
2962 Stloc(_runtextposLocal);
2963 PushTrack(rentedLocalBuilder11);
2964 TrackUnique2(7);
2965 Advance();
2966 MarkLabel(l12);
2967 ReadyReplaceStack(0);
2968 PopTrack();
2969 DoReplace();
2970 PushStack(rentedLocalBuilder11);
2971 }
2972 Back();
2973 break;
2974 }
2975 case 284:
2976 {
2977 PopTrack();
2978 using (RentedLocalBuilder rentedLocalBuilder12 = RentInt32Local())
2979 {
2980 Stloc(rentedLocalBuilder12);
2981 ReadyPushStack();
2982 PopTrack();
2983 DoPush();
2984 PushStack(rentedLocalBuilder12);
2985 }
2986 Back();
2987 break;
2988 }
2989 case 29:
2990 {
2991 PopStack();
2992 using (RentedLocalBuilder rentedLocalBuilder8 = RentInt32Local())
2993 {
2994 Stloc(rentedLocalBuilder8);
2995 PopStack();
2996 using (RentedLocalBuilder rentedLocalBuilder9 = RentInt32Local())
2997 {
2998 Stloc(rentedLocalBuilder9);
2999 Label l10 = DefineLabel();
3000 Ldloc(rentedLocalBuilder8);
3001 Ldc(0);
3002 Bge(l10);
3003 PushTrack(rentedLocalBuilder9);
3004 PushStack(_runtextposLocal);
3005 ReadyPushStack();
3006 Ldloc(rentedLocalBuilder8);
3007 Ldc(1);
3008 Add();
3009 DoPush();
3010 TrackUnique2(8);
3011 Goto(Operand(0));
3012 MarkLabel(l10);
3013 PushTrack(rentedLocalBuilder9);
3014 }
3015 PushTrack(rentedLocalBuilder8);
3016 }
3017 PushTrack(_runtextposLocal);
3018 Track();
3019 break;
3020 }
3021 case 157:
3022 {
3023 using (RentedLocalBuilder rentedLocalBuilder4 = RentInt32Local())
3024 {
3025 Label l4 = DefineLabel();
3026 PopTrack();
3027 Stloc(_runtextposLocal);
3028 PopTrack();
3029 Stloc(rentedLocalBuilder4);
3030 Ldloc(rentedLocalBuilder4);
3031 Ldc(Operand(1));
3032 Bge(l4);
3033 Ldloc(_runtextposLocal);
3034 TopTrack();
3035 Beq(l4);
3036 PushStack(_runtextposLocal);
3037 ReadyPushStack();
3038 Ldloc(rentedLocalBuilder4);
3039 Ldc(1);
3040 Add();
3041 DoPush();
3042 TrackUnique2(8);
3043 Goto(Operand(0));
3044 MarkLabel(l4);
3045 ReadyPushStack();
3046 PopTrack();
3047 DoPush();
3048 PushStack(rentedLocalBuilder4);
3049 }
3050 Back();
3051 break;
3052 }
3053 case 285:
3054 ReadyReplaceStack(1);
3055 PopTrack();
3056 DoReplace();
3057 ReadyReplaceStack(0);
3058 TopStack();
3059 Ldc(1);
3060 Sub();
3061 DoReplace();
3062 Back();
3063 break;
3064 case 34:
3065 ReadyPushStack();
3066 Ldthisfld(s_runtrackField);
3067 Ldlen();
3068 Ldloc(_runtrackposLocal);
3069 Sub();
3070 DoPush();
3071 ReadyPushStack();
3072 Ldthis();
3073 Call(s_crawlposMethod);
3074 DoPush();
3075 TrackUnique(1);
3076 break;
3077 case 162:
3078 PopDiscardStack(2);
3079 Back();
3080 break;
3081 case 35:
3082 {
3083 Label l = DefineLabel();
3084 Label l2 = DefineLabel();
3085 using (RentedLocalBuilder rentedLocalBuilder2 = RentInt32Local())
3086 {
3087 PopStack();
3088 Stloc(rentedLocalBuilder2);
3089 Ldthisfld(s_runtrackField);
3090 Ldlen();
3091 PopStack();
3092 Sub();
3093 Stloc(_runtrackposLocal);
3094 MarkLabel(l);
3095 Ldthis();
3096 Call(s_crawlposMethod);
3097 Ldloc(rentedLocalBuilder2);
3098 Beq(l2);
3099 Ldthis();
3100 Call(s_uncaptureMethod);
3101 Br(l);
3102 }
3103 MarkLabel(l2);
3104 Back();
3105 break;
3106 }
3107 case 36:
3108 {
3109 PopStack();
3110 using (RentedLocalBuilder rentedLocalBuilder21 = RentInt32Local())
3111 {
3112 Stloc(rentedLocalBuilder21);
3113 Ldthisfld(s_runtrackField);
3114 Ldlen();
3115 PopStack();
3116 Sub();
3117 Stloc(_runtrackposLocal);
3118 PushTrack(rentedLocalBuilder21);
3119 }
3120 TrackUnique(9);
3121 break;
3122 }
3123 case 164:
3124 {
3125 Label l22 = DefineLabel();
3126 Label l23 = DefineLabel();
3127 using (RentedLocalBuilder rentedLocalBuilder19 = RentInt32Local())
3128 {
3129 PopTrack();
3130 Stloc(rentedLocalBuilder19);
3131 MarkLabel(l22);
3132 Ldthis();
3133 Call(s_crawlposMethod);
3134 Ldloc(rentedLocalBuilder19);
3135 Beq(l23);
3136 Ldthis();
3137 Call(s_uncaptureMethod);
3138 Br(l22);
3139 }
3140 MarkLabel(l23);
3141 Back();
3142 break;
3143 }
3144 case 14:
3145 {
3146 Label l21 = _labels[NextCodepos()];
3147 Ldloc(_runtextposLocal);
3148 Ldloc(_runtextbegLocal);
3149 Ble(l21);
3150 Leftchar();
3151 Ldc(10);
3152 BneFar(_backtrack);
3153 break;
3154 }
3155 case 15:
3156 {
3157 Label l20 = _labels[NextCodepos()];
3158 Ldloc(_runtextposLocal);
3159 Ldloc(_runtextendLocal);
3160 Bge(l20);
3161 Rightchar();
3162 Ldc(10);
3163 BneFar(_backtrack);
3164 break;
3165 }
3166 case 16:
3167 case 17:
3168 Ldthis();
3169 Ldloc(_runtextposLocal);
3170 Ldloc(_runtextbegLocal);
3171 Ldloc(_runtextendLocal);
3172 Call(s_isBoundaryMethod);
3173 if (Code() == 16)
3174 {
3175 BrfalseFar(_backtrack);
3176 }
3177 else
3178 {
3179 BrtrueFar(_backtrack);
3180 }
3181 break;
3182 case 41:
3183 case 42:
3184 Ldthis();
3185 Ldloc(_runtextposLocal);
3186 Ldloc(_runtextbegLocal);
3187 Ldloc(_runtextendLocal);
3188 Call(s_isECMABoundaryMethod);
3189 if (Code() == 41)
3190 {
3191 BrfalseFar(_backtrack);
3192 }
3193 else
3194 {
3195 BrtrueFar(_backtrack);
3196 }
3197 break;
3198 case 18:
3199 Ldloc(_runtextposLocal);
3200 Ldloc(_runtextbegLocal);
3201 BgtFar(_backtrack);
3202 break;
3203 case 19:
3204 Ldloc(_runtextposLocal);
3205 Ldthisfld(s_runtextstartField);
3206 BneFar(_backtrack);
3207 break;
3208 case 20:
3209 Ldloc(_runtextposLocal);
3210 Ldloc(_runtextendLocal);
3211 Ldc(1);
3212 Sub();
3213 BltFar(_backtrack);
3214 Ldloc(_runtextposLocal);
3215 Ldloc(_runtextendLocal);
3216 Bge(_labels[NextCodepos()]);
3217 Rightchar();
3218 Ldc(10);
3219 BneFar(_backtrack);
3220 break;
3221 case 21:
3222 Ldloc(_runtextposLocal);
3223 Ldloc(_runtextendLocal);
3224 BltFar(_backtrack);
3225 break;
3226 case 9:
3227 case 10:
3228 case 11:
3229 case 73:
3230 case 74:
3231 case 75:
3232 case 521:
3233 case 522:
3234 case 523:
3235 case 585:
3236 case 586:
3237 case 587:
3238 Ldloc(_runtextposLocal);
3239 if (!IsRightToLeft())
3240 {
3241 Ldloc(_runtextendLocal);
3242 BgeFar(_backtrack);
3243 Rightcharnext();
3244 }
3245 else
3246 {
3247 Ldloc(_runtextbegLocal);
3248 BleFar(_backtrack);
3249 Leftcharnext();
3250 }
3251 if (Code() == 11)
3252 {
3253 EmitMatchCharacterClass(_strings[Operand(0)], IsCaseInsensitive());
3254 BrfalseFar(_backtrack);
3255 break;
3256 }
3257 if (IsCaseInsensitive() && ParticipatesInCaseConversion(Operand(0)))
3258 {
3259 CallToLower();
3260 }
3261 Ldc(Operand(0));
3262 if (Code() == 9)
3263 {
3264 BneFar(_backtrack);
3265 }
3266 else
3267 {
3268 BeqFar(_backtrack);
3269 }
3270 break;
3271 case 12:
3272 case 524:
3273 {
3274 string text3 = _strings[Operand(0)];
3275 Ldc(text3.Length);
3276 Ldloc(_runtextendLocal);
3277 Ldloc(_runtextposLocal);
3278 Sub();
3279 BgtFar(_backtrack);
3280 for (int i = 0; i < text3.Length; i++)
3281 {
3282 Ldloc(_runtextLocal);
3283 Ldloc(_runtextposLocal);
3284 if (i != 0)
3285 {
3286 Ldc(i);
3287 Add();
3288 }
3289 Call(s_stringGetCharsMethod);
3290 if (IsCaseInsensitive() && ParticipatesInCaseConversion(text3[i]))
3291 {
3292 CallToLower();
3293 }
3294 Ldc(text3[i]);
3295 BneFar(_backtrack);
3296 }
3297 Ldloc(_runtextposLocal);
3298 Ldc(text3.Length);
3299 Add();
3300 Stloc(_runtextposLocal);
3301 break;
3302 }
3303 case 76:
3304 case 588:
3305 {
3306 string text2 = _strings[Operand(0)];
3307 Ldc(text2.Length);
3308 Ldloc(_runtextposLocal);
3309 Ldloc(_runtextbegLocal);
3310 Sub();
3311 BgtFar(_backtrack);
3312 int num4 = text2.Length;
3313 while (num4 > 0)
3314 {
3315 num4--;
3316 Ldloc(_runtextLocal);
3317 Ldloc(_runtextposLocal);
3318 Ldc(text2.Length - num4);
3319 Sub();
3320 Call(s_stringGetCharsMethod);
3321 if (IsCaseInsensitive() && ParticipatesInCaseConversion(text2[num4]))
3322 {
3323 CallToLower();
3324 }
3325 Ldc(text2[num4]);
3326 BneFar(_backtrack);
3327 }
3328 Ldloc(_runtextposLocal);
3329 Ldc(text2.Length);
3330 Sub();
3331 Stloc(_runtextposLocal);
3332 break;
3333 }
3334 case 13:
3335 case 77:
3336 case 525:
3337 case 589:
3338 {
3339 using RentedLocalBuilder rentedLocalBuilder13 = RentInt32Local();
3340 using RentedLocalBuilder rentedLocalBuilder14 = RentInt32Local();
3341 Label l13 = DefineLabel();
3342 Ldthis();
3343 Ldc(Operand(0));
3344 Call(s_isMatchedMethod);
3345 if ((_options & RegexOptions.ECMAScript) != 0)
3346 {
3347 Brfalse(AdvanceLabel());
3348 }
3349 else
3350 {
3351 BrfalseFar(_backtrack);
3352 }
3353 Ldthis();
3354 Ldc(Operand(0));
3355 Call(s_matchLengthMethod);
3356 Stloc(rentedLocalBuilder13);
3357 Ldloc(rentedLocalBuilder13);
3358 if (!IsRightToLeft())
3359 {
3360 Ldloc(_runtextendLocal);
3361 Ldloc(_runtextposLocal);
3362 }
3363 else
3364 {
3365 Ldloc(_runtextposLocal);
3366 Ldloc(_runtextbegLocal);
3367 }
3368 Sub();
3369 BgtFar(_backtrack);
3370 Ldthis();
3371 Ldc(Operand(0));
3372 Call(s_matchIndexMethod);
3373 if (!IsRightToLeft())
3374 {
3375 Ldloc(rentedLocalBuilder13);
3376 Add(IsRightToLeft());
3377 }
3378 Stloc(rentedLocalBuilder14);
3379 Ldloc(_runtextposLocal);
3380 Ldloc(rentedLocalBuilder13);
3381 Add(IsRightToLeft());
3382 Stloc(_runtextposLocal);
3383 MarkLabel(l13);
3384 Ldloc(rentedLocalBuilder13);
3385 Ldc(0);
3386 Ble(AdvanceLabel());
3387 Ldloc(_runtextLocal);
3388 Ldloc(rentedLocalBuilder14);
3389 Ldloc(rentedLocalBuilder13);
3390 if (IsRightToLeft())
3391 {
3392 Ldc(1);
3393 Sub();
3394 Stloc(rentedLocalBuilder13);
3395 Ldloc(rentedLocalBuilder13);
3396 }
3397 Sub(IsRightToLeft());
3398 Call(s_stringGetCharsMethod);
3399 if (IsCaseInsensitive())
3400 {
3401 CallToLower();
3402 }
3403 Ldloc(_runtextLocal);
3404 Ldloc(_runtextposLocal);
3405 Ldloc(rentedLocalBuilder13);
3406 if (!IsRightToLeft())
3407 {
3408 Ldloc(rentedLocalBuilder13);
3409 Ldc(1);
3410 Sub();
3411 Stloc(rentedLocalBuilder13);
3412 }
3413 Sub(IsRightToLeft());
3414 Call(s_stringGetCharsMethod);
3415 if (IsCaseInsensitive())
3416 {
3417 CallToLower();
3418 }
3419 Beq(l13);
3420 Back();
3421 break;
3422 }
3423 case 0:
3424 case 1:
3425 case 2:
3426 case 64:
3427 case 65:
3428 case 66:
3429 case 512:
3430 case 513:
3431 case 514:
3432 case 576:
3433 case 577:
3434 case 578:
3435 {
3436 int num3 = Operand(1);
3437 if (num3 == 0)
3438 {
3439 break;
3440 }
3441 Ldc(num3);
3442 if (!IsRightToLeft())
3443 {
3444 Ldloc(_runtextendLocal);
3445 Ldloc(_runtextposLocal);
3446 }
3447 else
3448 {
3449 Ldloc(_runtextposLocal);
3450 Ldloc(_runtextbegLocal);
3451 }
3452 Sub();
3453 BgtFar(_backtrack);
3454 Ldloc(_runtextposLocal);
3455 Ldc(num3);
3456 Add(IsRightToLeft());
3457 Stloc(_runtextposLocal);
3458 using RentedLocalBuilder rentedLocalBuilder10 = RentInt32Local();
3459 Label l11 = DefineLabel();
3460 Ldc(num3);
3461 Stloc(rentedLocalBuilder10);
3462 MarkLabel(l11);
3463 Ldloc(_runtextLocal);
3464 Ldloc(_runtextposLocal);
3465 Ldloc(rentedLocalBuilder10);
3466 if (IsRightToLeft())
3467 {
3468 Ldc(1);
3469 Sub();
3470 Stloc(rentedLocalBuilder10);
3471 Ldloc(rentedLocalBuilder10);
3472 Add();
3473 }
3474 else
3475 {
3476 Ldloc(rentedLocalBuilder10);
3477 Ldc(1);
3478 Sub();
3479 Stloc(rentedLocalBuilder10);
3480 Sub();
3481 }
3482 Call(s_stringGetCharsMethod);
3483 if (Code() == 2)
3484 {
3485 EmitTimeoutCheck();
3486 EmitMatchCharacterClass(_strings[Operand(0)], IsCaseInsensitive());
3487 BrfalseFar(_backtrack);
3488 }
3489 else
3490 {
3491 if (IsCaseInsensitive() && ParticipatesInCaseConversion(Operand(0)))
3492 {
3493 CallToLower();
3494 }
3495 Ldc(Operand(0));
3496 if (Code() == 0)
3497 {
3498 BneFar(_backtrack);
3499 }
3500 else
3501 {
3502 BeqFar(_backtrack);
3503 }
3504 }
3505 Ldloc(rentedLocalBuilder10);
3506 Ldc(0);
3507 if (Code() == 2)
3508 {
3509 BgtFar(l11);
3510 }
3511 else
3512 {
3513 Bgt(l11);
3514 }
3515 break;
3516 }
3517 case 3:
3518 case 4:
3519 case 5:
3520 case 43:
3521 case 44:
3522 case 45:
3523 case 67:
3524 case 68:
3525 case 69:
3526 case 107:
3527 case 108:
3528 case 109:
3529 case 515:
3530 case 516:
3531 case 517:
3532 case 555:
3533 case 556:
3534 case 557:
3535 case 579:
3536 case 580:
3537 case 581:
3538 case 619:
3539 case 620:
3540 case 621:
3541 {
3542 int num2 = Operand(1);
3543 if (num2 == 0)
3544 {
3545 break;
3546 }
3547 using RentedLocalBuilder rentedLocalBuilder6 = RentInt32Local();
3548 using RentedLocalBuilder rentedLocalBuilder7 = RentInt32Local();
3549 if (!IsRightToLeft())
3550 {
3551 Ldloc(_runtextendLocal);
3552 Ldloc(_runtextposLocal);
3553 }
3554 else
3555 {
3556 Ldloc(_runtextposLocal);
3557 Ldloc(_runtextbegLocal);
3558 }
3559 Sub();
3560 Stloc(rentedLocalBuilder6);
3561 if (num2 != int.MaxValue)
3562 {
3563 Label l5 = DefineLabel();
3564 Ldloc(rentedLocalBuilder6);
3565 Ldc(num2);
3566 Blt(l5);
3567 Ldc(num2);
3568 Stloc(rentedLocalBuilder6);
3569 MarkLabel(l5);
3570 }
3571 Label l6 = DefineLabel();
3572 string text = ((Code() == 5 || Code() == 45) ? _strings[Operand(0)] : null);
3573 Span<char> chars = stackalloc char[3];
3574 int setChars;
3575 if ((Code() == 4 || Code() == 44) && !IsRightToLeft() && (!IsCaseInsensitive() || !ParticipatesInCaseConversion(Operand(0))))
3576 {
3577 Ldloc(_runtextLocal);
3578 Ldloc(_runtextposLocal);
3579 Ldloc(rentedLocalBuilder6);
3580 Call(s_stringAsSpanIntIntMethod);
3581 Ldc(Operand(0));
3582 Call(s_spanIndexOf);
3583 Stloc(rentedLocalBuilder7);
3584 Label l7 = DefineLabel();
3585 Ldloc(rentedLocalBuilder7);
3586 Ldc(-1);
3587 Bne(l7);
3588 Ldloc(_runtextposLocal);
3589 Ldloc(rentedLocalBuilder6);
3590 Add();
3591 Stloc(_runtextposLocal);
3592 Ldc(0);
3593 Stloc(rentedLocalBuilder7);
3594 BrFar(l6);
3595 MarkLabel(l7);
3596 Ldloc(_runtextposLocal);
3597 Ldloc(rentedLocalBuilder7);
3598 Add();
3599 Stloc(_runtextposLocal);
3600 Ldloc(rentedLocalBuilder6);
3601 Ldloc(rentedLocalBuilder7);
3602 Sub();
3603 Stloc(rentedLocalBuilder7);
3604 BrFar(l6);
3605 }
3606 else if ((Code() == 5 || Code() == 45) && !IsRightToLeft() && !IsCaseInsensitive() && (setChars = RegexCharClass.GetSetChars(text, chars)) > 1 && RegexCharClass.IsNegated(text))
3607 {
3608 Ldloc(_runtextLocal);
3609 Ldloc(_runtextposLocal);
3610 Ldloc(rentedLocalBuilder6);
3611 Call(s_stringAsSpanIntIntMethod);
3612 Ldc(chars[0]);
3613 Ldc(chars[1]);
3614 if (setChars == 2)
3615 {
3616 Call(s_spanIndexOfAnyCharChar);
3617 }
3618 else
3619 {
3620 Ldc(chars[2]);
3621 Call(s_spanIndexOfAnyCharCharChar);
3622 }
3623 Stloc(rentedLocalBuilder7);
3624 Label l8 = DefineLabel();
3625 Ldloc(rentedLocalBuilder7);
3626 Ldc(-1);
3627 Bne(l8);
3628 Ldloc(_runtextposLocal);
3629 Ldloc(rentedLocalBuilder6);
3630 Add();
3631 Stloc(_runtextposLocal);
3632 Ldc(0);
3633 Stloc(rentedLocalBuilder7);
3634 BrFar(l6);
3635 MarkLabel(l8);
3636 Ldloc(_runtextposLocal);
3637 Ldloc(rentedLocalBuilder7);
3638 Add();
3639 Stloc(_runtextposLocal);
3640 Ldloc(rentedLocalBuilder6);
3641 Ldloc(rentedLocalBuilder7);
3642 Sub();
3643 Stloc(rentedLocalBuilder7);
3644 BrFar(l6);
3645 }
3646 else if ((Code() == 5 || Code() == 45) && !IsRightToLeft() && text == "\0\u0001\0\0")
3647 {
3648 Ldloc(_runtextposLocal);
3649 Ldloc(rentedLocalBuilder6);
3650 Add();
3651 Stloc(_runtextposLocal);
3652 Ldc(0);
3653 Stloc(rentedLocalBuilder7);
3654 BrFar(l6);
3655 }
3656 else
3657 {
3658 Ldloc(rentedLocalBuilder6);
3659 Ldc(1);
3660 Add();
3661 Stloc(rentedLocalBuilder7);
3662 Label l9 = DefineLabel();
3663 MarkLabel(l9);
3664 Ldloc(rentedLocalBuilder7);
3665 Ldc(1);
3666 Sub();
3667 Stloc(rentedLocalBuilder7);
3668 Ldloc(rentedLocalBuilder7);
3669 Ldc(0);
3670 if (Code() == 5 || Code() == 45)
3671 {
3672 BleFar(l6);
3673 }
3674 else
3675 {
3676 Ble(l6);
3677 }
3678 if (IsRightToLeft())
3679 {
3680 Leftcharnext();
3681 }
3682 else
3683 {
3684 Rightcharnext();
3685 }
3686 if (Code() == 5 || Code() == 45)
3687 {
3688 EmitTimeoutCheck();
3689 EmitMatchCharacterClass(_strings[Operand(0)], IsCaseInsensitive());
3690 BrtrueFar(l9);
3691 }
3692 else
3693 {
3694 if (IsCaseInsensitive() && ParticipatesInCaseConversion(Operand(0)))
3695 {
3696 CallToLower();
3697 }
3698 Ldc(Operand(0));
3699 if (Code() == 3 || Code() == 43)
3700 {
3701 Beq(l9);
3702 }
3703 else
3704 {
3705 Bne(l9);
3706 }
3707 }
3708 Ldloc(_runtextposLocal);
3709 Ldc(1);
3710 Sub(IsRightToLeft());
3711 Stloc(_runtextposLocal);
3712 }
3713 MarkLabel(l6);
3714 if (Code() != 43 && Code() != 44 && Code() != 45)
3715 {
3716 Ldloc(rentedLocalBuilder6);
3717 Ldloc(rentedLocalBuilder7);
3718 Ble(AdvanceLabel());
3719 ReadyPushTrack();
3720 Ldloc(rentedLocalBuilder6);
3721 Ldloc(rentedLocalBuilder7);
3722 Sub();
3723 Ldc(1);
3724 Sub();
3725 DoPush();
3726 ReadyPushTrack();
3727 Ldloc(_runtextposLocal);
3728 Ldc(1);
3729 Sub(IsRightToLeft());
3730 DoPush();
3731 Track();
3732 }
3733 break;
3734 }
3735 case 131:
3736 case 132:
3737 case 133:
3738 case 195:
3739 case 196:
3740 case 197:
3741 case 643:
3742 case 644:
3743 case 645:
3744 case 707:
3745 case 708:
3746 case 709:
3747 {
3748 PopTrack();
3749 Stloc(_runtextposLocal);
3750 PopTrack();
3751 using (RentedLocalBuilder rentedLocalBuilder5 = RentInt32Local())
3752 {
3753 Stloc(rentedLocalBuilder5);
3754 Ldloc(rentedLocalBuilder5);
3755 Ldc(0);
3756 BleFar(AdvanceLabel());
3757 ReadyPushTrack();
3758 Ldloc(rentedLocalBuilder5);
3759 }
3760 Ldc(1);
3761 Sub();
3762 DoPush();
3763 ReadyPushTrack();
3764 Ldloc(_runtextposLocal);
3765 Ldc(1);
3766 Sub(IsRightToLeft());
3767 DoPush();
3768 Trackagain();
3769 Advance();
3770 break;
3771 }
3772 case 6:
3773 case 7:
3774 case 8:
3775 case 70:
3776 case 71:
3777 case 72:
3778 case 518:
3779 case 519:
3780 case 520:
3781 case 582:
3782 case 583:
3783 case 584:
3784 {
3785 int num = Operand(1);
3786 if (num == 0)
3787 {
3788 break;
3789 }
3790 if (!IsRightToLeft())
3791 {
3792 Ldloc(_runtextendLocal);
3793 Ldloc(_runtextposLocal);
3794 }
3795 else
3796 {
3797 Ldloc(_runtextposLocal);
3798 Ldloc(_runtextbegLocal);
3799 }
3800 Sub();
3801 using (RentedLocalBuilder rentedLocalBuilder3 = RentInt32Local())
3802 {
3803 Stloc(rentedLocalBuilder3);
3804 if (num != int.MaxValue)
3805 {
3806 Label l3 = DefineLabel();
3807 Ldloc(rentedLocalBuilder3);
3808 Ldc(num);
3809 Blt(l3);
3810 Ldc(num);
3811 Stloc(rentedLocalBuilder3);
3812 MarkLabel(l3);
3813 }
3814 Ldloc(rentedLocalBuilder3);
3815 Ldc(0);
3816 Ble(AdvanceLabel());
3817 ReadyPushTrack();
3818 Ldloc(rentedLocalBuilder3);
3819 }
3820 Ldc(1);
3821 Sub();
3822 DoPush();
3823 PushTrack(_runtextposLocal);
3824 Track();
3825 break;
3826 }
3827 case 134:
3828 case 135:
3829 case 136:
3830 case 198:
3831 case 199:
3832 case 200:
3833 case 646:
3834 case 647:
3835 case 648:
3836 case 710:
3837 case 711:
3838 case 712:
3839 {
3840 PopTrack();
3841 Stloc(_runtextposLocal);
3842 PopTrack();
3843 using (RentedLocalBuilder rentedLocalBuilder = RentInt32Local())
3844 {
3845 Stloc(rentedLocalBuilder);
3846 if (!IsRightToLeft())
3847 {
3848 Rightcharnext();
3849 }
3850 else
3851 {
3852 Leftcharnext();
3853 }
3854 if (Code() == 8)
3855 {
3856 EmitMatchCharacterClass(_strings[Operand(0)], IsCaseInsensitive());
3857 BrfalseFar(_backtrack);
3858 }
3859 else
3860 {
3861 if (IsCaseInsensitive() && ParticipatesInCaseConversion(Operand(0)))
3862 {
3863 CallToLower();
3864 }
3865 Ldc(Operand(0));
3866 if (Code() == 6)
3867 {
3868 BneFar(_backtrack);
3869 }
3870 else
3871 {
3872 BeqFar(_backtrack);
3873 }
3874 }
3875 Ldloc(rentedLocalBuilder);
3876 Ldc(0);
3877 BleFar(AdvanceLabel());
3878 ReadyPushTrack();
3879 Ldloc(rentedLocalBuilder);
3880 }
3881 Ldc(1);
3882 Sub();
3883 DoPush();
3884 PushTrack(_runtextposLocal);
3885 Trackagain();
3886 Advance();
3887 break;
3888 }
3889 }
3890 }
System.Text.RegularExpressions.RegexCompiler.s_runtextstartField
static readonly FieldInfo s_runtextstartField
Definition RegexCompiler.cs:55
System.Text.RegularExpressions.RegexCompiler.s_isMatchedMethod
static readonly MethodInfo s_isMatchedMethod
Definition RegexCompiler.cs:81
System.Text.RegularExpressions.RegexCompiler.EmitMatchCharacterClass
void EmitMatchCharacterClass(string charClass, bool caseInsensitive)
Definition RegexCompiler.cs:3892
System.Text.RegularExpressions.RegexCompiler.s_checkTimeoutMethod
static readonly MethodInfo s_checkTimeoutMethod
Definition RegexCompiler.cs:95
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_transferCaptureMethod
static readonly MethodInfo s_transferCaptureMethod
Definition RegexCompiler.cs:77
System.Text.RegularExpressions.RegexCompiler.s_matchIndexMethod
static readonly MethodInfo s_matchIndexMethod
Definition RegexCompiler.cs:85
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_matchLengthMethod
static readonly MethodInfo s_matchLengthMethod
Definition RegexCompiler.cs:83
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.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_captureMethod
static readonly MethodInfo s_captureMethod
Definition RegexCompiler.cs:75
System.Text.RegularExpressions.RegexCompiler.s_isBoundaryMethod
static readonly MethodInfo s_isBoundaryMethod
Definition RegexCompiler.cs:87
System.Text.RegularExpressions.RegexCompiler.s_runtextposField
static readonly FieldInfo s_runtextposField
Definition RegexCompiler.cs:57

References System.Text.RegularExpressions.RegexCompiler._backtrack, System.Text.RegularExpressions.RegexCompiler._hasTimeout, System.Text.RegularExpressions.RegexCompiler._labels, System.Text.RegularExpressions.RegexCompiler._options, System.Text.RegularExpressions.RegexCompiler._regexopcode, System.Text.RegularExpressions.RegexCompiler._runtextbegLocal, System.Text.RegularExpressions.RegexCompiler._runtextendLocal, System.Text.RegularExpressions.RegexCompiler._runtextLocal, System.Text.RegularExpressions.RegexCompiler._runtextposLocal, System.Text.RegularExpressions.RegexCompiler._runtrackLocal, System.Text.RegularExpressions.RegexCompiler._runtrackposLocal, System.Text.RegularExpressions.RegexCompiler._strings, System.Text.RegularExpressions.RegexCompiler.Add(), System.Text.RegularExpressions.RegexCompiler.Advance(), System.Text.RegularExpressions.RegexCompiler.AdvanceLabel(), System.Text.RegularExpressions.RegexCompiler.Back(), 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.Reflection.Emit.Ble, System.Text.RegularExpressions.RegexCompiler.BleFar(), System.Reflection.Emit.Blt, System.Text.RegularExpressions.RegexCompiler.BltFar(), System.Text.RegularExpressions.RegexCompiler.Bne(), System.Text.RegularExpressions.RegexCompiler.BneFar(), System.Reflection.Emit.Br, System.Reflection.Emit.Brfalse, System.Text.RegularExpressions.RegexCompiler.BrfalseFar(), System.Text.RegularExpressions.RegexCompiler.BrFar(), System.Text.RegularExpressions.RegexCompiler.BrtrueFar(), System.Reflection.Emit.Call, System.Text.RegularExpressions.RegexCompiler.CallToLower(), System.chars, System.Text.RegularExpressions.RegexCompiler.Code(), System.Text.RegularExpressions.RegexCompiler.DefineLabel(), System.Text.RegularExpressions.RegexCompiler.DoPush(), System.Text.RegularExpressions.RegexCompiler.DoReplace(), System.Text.RegularExpressions.RegexCompiler.Dup(), System.Text.RegularExpressions.RegexCompiler.EmitMatchCharacterClass(), System.Text.RegularExpressions.RegexCompiler.EmitTimeoutCheck(), System.Text.RegularExpressions.RegexCharClass.GetSetChars(), System.Text.RegularExpressions.RegexCompiler.Goto(), System.Text.RegularExpressions.i, System.Text.RegularExpressions.RegexCompiler.IsCaseInsensitive(), System.Text.RegularExpressions.RegexCharClass.IsNegated(), System.Text.RegularExpressions.RegexCompiler.IsRightToLeft(), System.Text.RegularExpressions.RegexCompiler.Ldc(), System.Text.RegularExpressions.RegexCompiler.Ldlen(), System.Reflection.Emit.Ldloc, System.Text.RegularExpressions.RegexCompiler.Ldthis(), System.Text.RegularExpressions.RegexCompiler.Ldthisfld(), System.Text.RegularExpressions.RegexCompiler.Leftchar(), System.Text.RegularExpressions.RegexCompiler.Leftcharnext(), System.Text.RegularExpressions.RegexCompiler.MarkLabel(), System.Reflection.MaxValue, System.Text.RegularExpressions.RegexCompiler.Mvlocfld(), System.Text.RegularExpressions.RegexCompiler.NextCodepos(), System.Text.RegularExpressions.RegexCompiler.Operand(), System.Text.RegularExpressions.RegexCompiler.ParticipatesInCaseConversion(), System.Text.RegularExpressions.RegexCompiler.Pop(), System.Text.RegularExpressions.RegexCompiler.PopDiscardStack(), System.Text.RegularExpressions.RegexCompiler.PopStack(), System.Text.RegularExpressions.RegexCompiler.PopTrack(), System.Text.RegularExpressions.RegexCompiler.PushStack(), System.Text.RegularExpressions.RegexCompiler.PushTrack(), System.Text.RegularExpressions.RegexCompiler.ReadyPushStack(), System.Text.RegularExpressions.RegexCompiler.ReadyPushTrack(), System.Text.RegularExpressions.RegexCompiler.ReadyReplaceStack(), System.Text.RegularExpressions.RegexCompiler.RentInt32Local(), System.Text.RegularExpressions.RegexCompiler.Ret(), System.Text.RegularExpressions.RegexCompiler.Rightchar(), System.Text.RegularExpressions.RegexCompiler.Rightcharnext(), System.Text.RegularExpressions.RegexCompiler.s_captureMethod, System.Text.RegularExpressions.RegexCompiler.s_checkTimeoutMethod, System.Text.RegularExpressions.RegexCompiler.s_crawlposMethod, System.Text.RegularExpressions.RegexCompiler.s_isBoundaryMethod, System.Text.RegularExpressions.RegexCompiler.s_isECMABoundaryMethod, System.Text.RegularExpressions.RegexCompiler.s_isMatchedMethod, System.Text.RegularExpressions.RegexCompiler.s_matchIndexMethod, System.Text.RegularExpressions.RegexCompiler.s_matchLengthMethod, System.Text.RegularExpressions.RegexCompiler.s_runtextposField, System.Text.RegularExpressions.RegexCompiler.s_runtextstartField, System.Text.RegularExpressions.RegexCompiler.s_runtrackField, System.Text.RegularExpressions.RegexCompiler.s_spanIndexOf, System.Text.RegularExpressions.RegexCompiler.s_spanIndexOfAnyCharChar, System.Text.RegularExpressions.RegexCompiler.s_spanIndexOfAnyCharCharChar, System.Text.RegularExpressions.RegexCompiler.s_stringAsSpanIntIntMethod, System.Text.RegularExpressions.RegexCompiler.s_stringGetCharsMethod, System.Text.RegularExpressions.RegexCompiler.s_transferCaptureMethod, System.Text.RegularExpressions.RegexCompiler.s_uncaptureMethod, System.Text.RegularExpressions.RegexCompiler.StelemI4(), System.Reflection.Emit.Stloc, System.Text.RegularExpressions.RegexCompiler.Sub(), System.text, System.Text.RegularExpressions.RegexCompiler.TopStack(), System.Text.RegularExpressions.RegexCompiler.TopTrack(), System.Text.RegularExpressions.RegexCompiler.Track(), System.Text.RegularExpressions.RegexCompiler.Trackagain(), System.Text.RegularExpressions.RegexCompiler.TrackUnique(), and System.Text.RegularExpressions.RegexCompiler.TrackUnique2().

Referenced by System.Text.RegularExpressions.RegexCompiler.GenerateBacktrackSection(), and System.Text.RegularExpressions.RegexCompiler.GenerateForwardSection().