2156{
2157
2159
2160
2162
2163
2165
2167
2169
2170
2171
2172
2173
2174
2175
2176
2177
2181
2182
2186
2188
2191
2193
2194
2196
2197#if YYERROR_VERBOSE
2198
2202#endif
2203
2204#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
2205
2206
2207
2209
2214
2216
2221
2222
2223
2224
2225
2228
2230
2231
2232
2233
2235
2236
2238
2241
2243 {
2244
2246
2247#ifdef yyoverflow
2248 {
2249
2250
2251
2254
2255
2256
2257
2258
2263
2266 }
2267#else
2268# ifndef YYSTACK_RELOCATE
2270# else
2271
2277
2278 {
2286# undef YYSTACK_RELOCATE
2289 }
2290# endif
2291#endif
2292
2295
2298
2301 }
2302
2304
2307
2309
2310
2311
2312
2314
2315
2316
2317
2318
2322
2323
2324
2325
2327 {
2330 }
2331
2333 {
2336 }
2337 else
2338 {
2341 }
2342
2343
2344
2350 {
2355 }
2356
2357
2358
2361
2362
2364
2365
2367
2370
2372
2373
2374
2375
2376
2382
2383
2384
2385
2386
2388
2390
2391
2392
2393
2394
2395
2396
2397
2398
2400
2401
2404 {
2405 case 3:
2406
2407
2408#line 322 "grammar.y"
2409 {
2411 {
2414 }
2416 {
2419 }
2421#ifdef HAVE_SDB
2423#endif
2425 {
2429 }
2431 {
2433 }
2438 ;}
2439 break;
2440
2441 case 5:
2442
2443
2444#line 357 "grammar.y"
2446 break;
2447
2448 case 6:
2449
2450
2451#line 359 "grammar.y"
2453 break;
2454
2455 case 7:
2456
2457
2458#line 361 "grammar.y"
2459 {
2461 ;}
2462 break;
2463
2464 case 8:
2465
2466
2467#line 365 "grammar.y"
2468 {
2471 ;}
2472 break;
2473
2474 case 9:
2475
2476
2477#line 370 "grammar.y"
2479 break;
2480
2481 case 10:
2482
2483
2484#line 372 "grammar.y"
2485 {
2486 #ifdef SIQ
2488 #endif
2492 {
2493
2495 {
2496
2497
2498
2501 }
2502
2503
2504 }
2508#ifdef HAVE_SDB
2510 {
2512 }
2513 else
2514#endif
2516 {
2518
2522 else
2524 }
2526 {
2528 }
2529#ifdef HAVE_SDB
2531#endif
2532 ;}
2533 break;
2534
2535 case 18:
2536
2537
2538#line 430 "grammar.y"
2540 break;
2541
2542 case 19:
2543
2544
2545#line 433 "grammar.y"
2547 break;
2548
2549 case 29:
2550
2551
2552#line 448 "grammar.y"
2553 {
2555 ;}
2556 break;
2557
2558 case 30:
2559
2560
2561#line 455 "grammar.y"
2562 {
2565 ;}
2566 break;
2567
2568 case 31:
2569
2570
2571#line 460 "grammar.y"
2572 {
2574 ;}
2575 break;
2576
2577 case 32:
2578
2579
2580#line 464 "grammar.y"
2581 {
2583 ;}
2584 break;
2585
2586 case 33:
2587
2588
2589#line 468 "grammar.y"
2590 {
2592 ;}
2593 break;
2594
2595 case 34:
2596
2597
2598#line 472 "grammar.y"
2599 {
2601 ;}
2602 break;
2603
2604 case 35:
2605
2606
2607#line 476 "grammar.y"
2608 {
2610 {
2614 }
2616 {
2618 }
2620 ;}
2621 break;
2622
2623 case 36:
2624
2625
2626#line 490 "grammar.y"
2627 {
2634 {
2640 {
2642 (
yyvsp[(2) - (3)].lv).CleanUp();
2644 }
2651 }
2652 (
yyvsp[(2) - (3)].lv).CleanUp();
2653 ;}
2654 break;
2655
2656 case 37:
2657
2658
2659#line 518 "grammar.y"
2660 {
2663
2664
2667
2668
2672 {
2676 {
2679 (
yyval.lv).data = n;
2680 }
2681 }
2682 ;}
2683 break;
2684
2685 case 38:
2686
2687
2688#line 542 "grammar.y"
2689 {
2693 ;}
2694 break;
2695
2696 case 39:
2697
2698
2699#line 548 "grammar.y"
2700 {
2704 ;}
2705 break;
2706
2707 case 40:
2708
2709
2710#line 554 "grammar.y"
2711 {
2713 ;}
2714 break;
2715
2716 case 41:
2717
2718
2719#line 558 "grammar.y"
2720 {
2722 ;}
2723 break;
2724
2725 case 42:
2726
2727
2728#line 562 "grammar.y"
2729 {
2731 ;}
2732 break;
2733
2734 case 43:
2735
2736
2737#line 566 "grammar.y"
2738 {
2740 ;}
2741 break;
2742
2743 case 44:
2744
2745
2746#line 570 "grammar.y"
2747 {
2749 ;}
2750 break;
2751
2752 case 45:
2753
2754
2755#line 574 "grammar.y"
2756 {
2758 ;}
2759 break;
2760
2761 case 46:
2762
2763
2764#line 578 "grammar.y"
2765 {
2767 ;}
2768 break;
2769
2770 case 47:
2771
2772
2773#line 582 "grammar.y"
2774 {
2776 ;}
2777 break;
2778
2779 case 48:
2780
2781
2782#line 586 "grammar.y"
2783 {
2785 ;}
2786 break;
2787
2788 case 49:
2789
2790
2791#line 590 "grammar.y"
2792 {
2794 ;}
2795 break;
2796
2797 case 50:
2798
2799
2800#line 594 "grammar.y"
2801 {
2803 ;}
2804 break;
2805
2806 case 51:
2807
2808
2809#line 598 "grammar.y"
2810 {
2812 ;}
2813 break;
2814
2815 case 52:
2816
2817
2818#line 602 "grammar.y"
2819 {
2821 ;}
2822 break;
2823
2824 case 53:
2825
2826
2827#line 606 "grammar.y"
2828 {
2830 ;}
2831 break;
2832
2833 case 54:
2834
2835
2836#line 610 "grammar.y"
2837 {
2839 ;}
2840 break;
2841
2842 case 55:
2843
2844
2845#line 614 "grammar.y"
2846 {
2848 ;}
2849 break;
2850
2851 case 56:
2852
2853
2854#line 618 "grammar.y"
2855 {
2857 ;}
2858 break;
2859
2860 case 57:
2861
2862
2863#line 622 "grammar.y"
2864 {
2866 ;}
2867 break;
2868
2869 case 58:
2870
2871
2872#line 626 "grammar.y"
2873 {
2875 ;}
2876 break;
2877
2878 case 59:
2879
2880
2881#line 630 "grammar.y"
2882 {
2884 ;}
2885 break;
2886
2887 case 60:
2888
2889
2890#line 634 "grammar.y"
2891 {
2895 ;}
2896 break;
2897
2898 case 61:
2899
2900
2901#line 640 "grammar.y"
2902 {
2904 ;}
2905 break;
2906
2907 case 62:
2908
2909
2910#line 644 "grammar.y"
2911 {
2913 ;}
2914 break;
2915
2916 case 63:
2917
2918
2919#line 648 "grammar.y"
2920 {
2922 ;}
2923 break;
2924
2925 case 64:
2926
2927
2928#line 652 "grammar.y"
2929 {
2931 ;}
2932 break;
2933
2934 case 65:
2935
2936
2937#line 656 "grammar.y"
2938 {
2941 ;}
2942 break;
2943
2944 case 66:
2945
2946
2947#line 660 "grammar.y"
2949 break;
2950
2951 case 67:
2952
2953
2954#line 665 "grammar.y"
2955 {
2958 {
2960 }
2964 ;}
2965 break;
2966
2967 case 71:
2968
2969
2970#line 681 "grammar.y"
2971 {
2973 ;}
2974 break;
2975
2976 case 72:
2977
2978
2979#line 685 "grammar.y"
2980 {
2982 ;}
2983 break;
2984
2985 case 73:
2986
2987
2988#line 689 "grammar.y"
2989 {
2991 ;}
2992 break;
2993
2994 case 74:
2995
2996
2997#line 693 "grammar.y"
2998 {
3000 ;}
3001 break;
3002
3003 case 75:
3004
3005
3006#line 697 "grammar.y"
3007 {
3009 ;}
3010 break;
3011
3012 case 76:
3013
3014
3015#line 701 "grammar.y"
3016 {
3018 ;}
3019 break;
3020
3021 case 77:
3022
3023
3024#line 705 "grammar.y"
3025 {
3027 ;}
3028 break;
3029
3030 case 78:
3031
3032
3033#line 709 "grammar.y"
3034 {
3036 ;}
3037 break;
3038
3039 case 79:
3040
3041
3042#line 713 "grammar.y"
3043 {
3045 ;}
3046 break;
3047
3048 case 80:
3049
3050
3051#line 717 "grammar.y"
3052 {
3053 #ifdef SIQ
3057 else
3058 #endif
3059 {
3063 }
3064 #ifdef SIQ
3066 #endif
3067 ;}
3068 break;
3069
3070 case 81:
3071
3072
3073#line 734 "grammar.y"
3074 {
3078 ;}
3079 break;
3080
3081 case 82:
3082
3083
3084#line 740 "grammar.y"
3085 {
3086 #ifdef SIQ
3088 #endif
3089 ;}
3090 break;
3091
3092 case 83:
3093
3094
3095#line 746 "grammar.y"
3096 {
3097 #ifdef SIQ
3098 if (
siq<=0) (
yyvsp[(4) - (5)].lv).Eval();
3099 #endif
3101 #ifdef SIQ
3103 #endif
3104 ;}
3105 break;
3106
3107 case 84:
3108
3109
3110#line 758 "grammar.y"
3111 {
3112 #ifdef SIQ
3114 #endif
3115 ;}
3116 break;
3117
3118 case 85:
3119
3120
3121#line 766 "grammar.y"
3122 {
3123 #ifdef SIQ
3125 #endif
3126 ;}
3127 break;
3128
3129 case 86:
3130
3131
3132#line 774 "grammar.y"
3133 {
3134 #ifdef SIQ
3136 #endif
3137 ;}
3138 break;
3139
3140 case 87:
3141
3142
3143#line 783 "grammar.y"
3144 {
3146 ;}
3147 break;
3148
3149 case 88:
3150
3151
3152#line 787 "grammar.y"
3153 {
3155 ;}
3156 break;
3157
3158 case 89:
3159
3160
3161#line 791 "grammar.y"
3162 {
3164 ;}
3165 break;
3166
3167 case 90:
3168
3169
3170#line 795 "grammar.y"
3171 {
3173 ;}
3174 break;
3175
3176 case 91:
3177
3178
3179#line 799 "grammar.y"
3180 {
3182 ;}
3183 break;
3184
3185 case 92:
3186
3187
3188#line 803 "grammar.y"
3189 {
3191 ;}
3192 break;
3193
3194 case 93:
3195
3196
3197#line 807 "grammar.y"
3198 {
3200 ;}
3201 break;
3202
3203 case 94:
3204
3205
3206#line 811 "grammar.y"
3207 {
3209 ;}
3210 break;
3211
3212 case 95:
3213
3214
3215#line 815 "grammar.y"
3216 {
3218 ;}
3219 break;
3220
3221 case 96:
3222
3223
3224#line 819 "grammar.y"
3225 {
3227 ;}
3228 break;
3229
3230 case 97:
3231
3232
3233#line 823 "grammar.y"
3234 {
3236 ;}
3237 break;
3238
3239 case 98:
3240
3241
3242#line 827 "grammar.y"
3243 {
3245 ;}
3246 break;
3247
3248 case 99:
3249
3250
3251#line 831 "grammar.y"
3252 {
3255 else
3256 {
3260 (
yyval.lv).data = (
void *)(
long)(
i == 0 ? 1 : 0);
3261 }
3262 ;}
3263 break;
3264
3265 case 100:
3266
3267
3268#line 843 "grammar.y"
3269 {
3271 ;}
3272 break;
3273
3274 case 102:
3275
3276
3277#line 851 "grammar.y"
3278 {
3279 if ((
yyvsp[(1) - (2)].lv).rtyp==0)
3280 {
3281 Werror(
"`%s` is undefined",(
yyvsp[(1) - (2)].lv).Fullname());
3283 }
3285
3287 {
3288 MYYERROR(
"matrix must have 2 indices");
3289 }
3291 ;}
3292 break;
3293
3294 case 104:
3295
3296
3297#line 871 "grammar.y"
3298 {
3300 {
3301 MYYERROR(
"string expression expected");
3302 }
3304 (
yyvsp[(2) - (3)].lv).CleanUp();
3305 ;}
3306 break;
3307
3308 case 105:
3309
3310
3311#line 883 "grammar.y"
3312 {
3315 ;}
3316 break;
3317
3318 case 106:
3319
3320
3321#line 888 "grammar.y"
3322 {
3325 ;}
3326 break;
3327
3328 case 107:
3329
3330
3331#line 893 "grammar.y"
3332 {
3334 ;}
3335 break;
3336
3337 case 108:
3338
3339
3340#line 897 "grammar.y"
3341 {
3343 ;}
3344 break;
3345
3346 case 109:
3347
3348
3349#line 901 "grammar.y"
3350 {
3356 {
3363 else
3366 }
3368 {
3374 {
3377 }
3378 else
3379 {
3382 }
3384 }
3385 ;}
3386 break;
3387
3388 case 110:
3389
3390
3391#line 938 "grammar.y"
3392 {
3394 {
3396 }
3398 {
3402 {
3405 do
3406 {
3412 }
3413 }
3414 ;}
3415 break;
3416
3417 case 111:
3418
3419
3420#line 962 "grammar.y"
3421 {
3422 int t=(
yyvsp[(1) - (3)].lv).Typ();
3426 {
3429 }
3430 else
3431 {
3434 }
3440 ;}
3441 break;
3442
3443 case 112:
3444
3445
3446#line 983 "grammar.y"
3447 {
3450 ;}
3451 break;
3452
3453 case 115:
3454
3455
3456#line 996 "grammar.y"
3457 {
3460 {
3462 }
3466 ;}
3467 break;
3468
3469 case 116:
3470
3471
3472#line 1010 "grammar.y"
3473 {
3474
3476 ;}
3477 break;
3478
3479 case 117:
3480
3481
3482#line 1018 "grammar.y"
3483 {
3486 (*iv)[0] = 1;
3487 (*iv)[1] = (
yyvsp[(1) - (1)].i);
3489 (
yyval.lv).data = (
void *)iv;
3490 ;}
3491 break;
3492
3493 case 118:
3494
3495
3496#line 1027 "grammar.y"
3497 {
3501 {
3506 (*iv)[1] = (
yyvsp[(1) - (4)].i);
3507
3509 while ((
i<
l) && (sl!=
NULL))
3510 {
3512 {
3513 (*iv)[
i++] = (
int)((
long)(sl->
Data()));
3514 }
3517 {
3521 {
3522 (*iv)[
i++] = (*ivv)[
ll++];
3523 }
3524 }
3525 else
3526 {
3527 delete iv;
3528 (
yyvsp[(3) - (4)].lv).CleanUp();
3529 MYYERROR(
"wrong type in ordering");
3530 }
3532 }
3534 (
yyval.lv).data = (
void *)iv;
3535 }
3536 (
yyvsp[(3) - (4)].lv).CleanUp();
3537 ;}
3538 break;
3539
3540 case 120:
3541
3542
3543#line 1073 "grammar.y"
3544 {
3548 ;}
3549 break;
3550
3551 case 122:
3552
3553
3554#line 1083 "grammar.y"
3555 {
3557 ;}
3558 break;
3559
3560 case 123:
3561
3562
3563#line 1089 "grammar.y"
3564 {
3566 ;}
3567 break;
3568
3569 case 128:
3570
3571
3572#line 1107 "grammar.y"
3574 break;
3575
3576 case 129:
3577
3578
3579#line 1112 "grammar.y"
3580 {
3583 ;}
3584 break;
3585
3586 case 130:
3587
3588
3589#line 1117 "grammar.y"
3590 {
3592 ;}
3593 break;
3594
3595 case 131:
3596
3597
3598#line 1124 "grammar.y"
3599 {
3602 ;}
3603 break;
3604
3605 case 132:
3606
3607
3608#line 1132 "grammar.y"
3609 {
3611 {
3613 }
3614 else
3616 ;}
3617 break;
3618
3619 case 133:
3620
3621
3622#line 1144 "grammar.y"
3623 {
3626 {
3628 {
3631 }
3633 }
3634 else
3635 {
3637 }
3638 ;}
3639 break;
3640
3641 case 134:
3642
3643
3644#line 1161 "grammar.y"
3645 {
3648 {
3650 {
3653 }
3655 }
3656 else
3657 {
3659 }
3660 ;}
3661 break;
3662
3663 case 135:
3664
3665
3666#line 1181 "grammar.y"
3667 {
3669 ;}
3670 break;
3671
3672 case 136:
3673
3674
3675#line 1185 "grammar.y"
3676 {
3678 ;}
3679 break;
3680
3681 case 137:
3682
3683
3684#line 1189 "grammar.y"
3685 {
3688 ;}
3689 break;
3690
3691 case 138:
3692
3693
3694#line 1194 "grammar.y"
3695 {
3697 ;}
3698 break;
3699
3700 case 139:
3701
3702
3703#line 1198 "grammar.y"
3704 {
3706 ;}
3707 break;
3708
3709 case 140:
3710
3711
3712#line 1202 "grammar.y"
3713 {
3715 ;}
3716 break;
3717
3718 case 141:
3719
3720
3721#line 1206 "grammar.y"
3722 {
3724 ;}
3725 break;
3726
3727 case 142:
3728
3729
3730#line 1210 "grammar.y"
3731 {
3733 (
yyvsp[(3) - (4)].lv).CleanUp();
3734 ;}
3735 break;
3736
3737 case 143:
3738
3739
3740#line 1215 "grammar.y"
3741 {
3744 (
yyvsp[(3) - (6)].lv).CleanUp();
3745 ;}
3746 break;
3747
3748 case 144:
3749
3750
3751#line 1221 "grammar.y"
3752 {
3755 (
yyvsp[(3) - (6)].lv).CleanUp();
3756 ;}
3757 break;
3758
3759 case 145:
3760
3761
3762#line 1227 "grammar.y"
3763 {
3766 (
yyvsp[(3) - (6)].lv).CleanUp();
3767 ;}
3768 break;
3769
3770 case 146:
3771
3772
3773#line 1233 "grammar.y"
3774 {
3777 (
yyvsp[(3) - (6)].lv).CleanUp();
3778 ;}
3779 break;
3780
3781 case 147:
3782
3783
3784#line 1239 "grammar.y"
3785 {
3788 (
yyvsp[(3) - (6)].lv).CleanUp();
3789 ;}
3790 break;
3791
3792 case 148:
3793
3794
3795#line 1245 "grammar.y"
3796 {
3799 (
yyvsp[(3) - (6)].lv).CleanUp();
3800 ;}
3801 break;
3802
3803 case 149:
3804
3805
3806#line 1251 "grammar.y"
3807 {
3810 (
yyvsp[(3) - (6)].lv).CleanUp();
3811 ;}
3812 break;
3813
3814 case 150:
3815
3816
3817#line 1263 "grammar.y"
3818 {
3820 ;}
3821 break;
3822
3823 case 151:
3824
3825
3826#line 1269 "grammar.y"
3828 break;
3829
3830 case 152:
3831
3832
3833#line 1278 "grammar.y"
3834 {
3838 &(
yyvsp[(6) - (8)].lv),
3839 &(
yyvsp[(8) - (8)].lv));
3841
3843 {
3845 &((
yyvsp[(2) - (8)].lv).req_packhdl->idroot),
FALSE);
3846 (
yyvsp[(2) - (8)].lv).CleanUp();
3848 {
3850 }
3851 else
3852 {
3854 }
3855 }
3858 {
3860 }
3861 else
3862 {
3864 }
3865 ;}
3866 break;
3867
3868 case 153:
3869
3870
3871#line 1311 "grammar.y"
3872 {
3876 (
yyvsp[(2) - (2)].lv).CleanUp();
3877 ;}
3878 break;
3879
3880 case 154:
3881
3882
3883#line 1318 "grammar.y"
3884 {
3887 ;}
3888 break;
3889
3890 case 155:
3891
3892
3893#line 1323 "grammar.y"
3894 {
3902 ;}
3903 break;
3904
3905 case 156:
3906
3907
3908#line 1336 "grammar.y"
3909 {
3912 ;}
3913 break;
3914
3915 case 159:
3916
3917
3918#line 1346 "grammar.y"
3919 {
3921 MYYERROR(
"only inside a proc allowed");
3922 const char * n=(
yyvsp[(2) - (2)].lv).Name();
3925 {
3928
3930 {
3932 {
3934 {
3936#if 1
3941 {
3943 {
3946 {
3951 }
3953 }
3955 }
3956#endif
3957 }
3959 }
3960 else
3961 {
3962 Werror(
"%s is no identifier",n);
3963 (
yyvsp[(2) - (2)].lv).CleanUp();
3965 }
3966 }
3968 else
3969 {
3970 Werror(
"cannot find the name of the basering %s",n);
3971 (
yyvsp[(2) - (2)].lv).CleanUp();
3973 }
3974 (
yyvsp[(2) - (2)].lv).CleanUp();
3975 }
3976 else
3977 {
3978 Werror(
"%s is no name of a ring/qring",n);
3979 (
yyvsp[(2) - (2)].lv).CleanUp();
3981 }
3982 ;}
3983 break;
3984
3985 case 160:
3986
3987
3988#line 1414 "grammar.y"
3989 {
3991 ;}
3992 break;
3993
3994 case 161:
3995
3996
3997#line 1418 "grammar.y"
3998 {
3999
4000 #ifdef SIQ
4002 {
4003 #endif
4005 {
4007 {
4010 }
4012 }
4013 #ifdef SIQ
4014 }
4015 #endif
4019 ;}
4020 break;
4021
4022 case 162:
4023
4024
4025#line 1447 "grammar.y"
4026 {
4029 {
4031 }
4032 else
4033 {
4036 }
4037 ;}
4038 break;
4039
4040 case 163:
4041
4042
4043#line 1460 "grammar.y"
4044 {
4046 {
4049 }
4050 else
4051 {
4053 {
4055 }
4057 }
4059 ;}
4060 break;
4061
4062 case 164:
4063
4064
4065#line 1477 "grammar.y"
4066 {
4069 {
4071 }
4073 ;}
4074 break;
4075
4076 case 165:
4077
4078
4079#line 1486 "grammar.y"
4080 {
4083 ;}
4084 break;
4085
4086 case 166:
4087
4088
4089#line 1491 "grammar.y"
4090 {
4093 ;}
4094 break;
4095
4096 case 167:
4097
4098
4099#line 1499 "grammar.y"
4100 {
4101
4108 ;}
4109 break;
4110
4111 case 168:
4112
4113
4114#line 1512 "grammar.y"
4115 {
4116
4117
4120 snprintf(
s,len,
"forif (!(%s)) break;\n%s%s;\ncontinue;\n "
4131 ;}
4132 break;
4133
4134 case 169:
4135
4136
4137#line 1533 "grammar.y"
4138 {
4143 sprintf(
IDPROC(
h)->data.s.body,
"parameter list #;\n%s;return();\n\n",(
yyvsp[(3) - (3)].name));
4146 ;}
4147 break;
4148
4149 case 170:
4150
4151
4152#line 1543 "grammar.y"
4153 {
4156 {
4161 }
4170 ;}
4171 break;
4172
4173 case 171:
4174
4175
4176#line 1562 "grammar.y"
4177 {
4181 {
4186 }
4195 ;}
4196 break;
4197
4198 case 172:
4199
4200
4201#line 1585 "grammar.y"
4202 {
4203
4206 ;}
4207 break;
4208
4209 case 173:
4210
4211
4212#line 1591 "grammar.y"
4213 {
4214
4220 ;}
4221 break;
4222
4223 case 174:
4224
4225
4226#line 1603 "grammar.y"
4227 {
4229 (
yyvsp[(3) - (4)].lv).CleanUp();
4231 ;}
4232 break;
4233
4234 case 175:
4235
4236
4237#line 1609 "grammar.y"
4238 {
4240 {
4244 }
4245 ;}
4246 break;
4247
4248
4249
4250
4251#line 4252 "grammar.cc"
4252 default: break;
4253 }
4255
4259
4261
4262
4263
4264
4265
4267
4271 else
4273
4275
4276
4277
4278
4279
4281
4283 {
4285#if ! YYERROR_VERBOSE
4287#else
4288 {
4291 {
4300 else
4301 {
4304 }
4305 }
4306
4308 {
4311 }
4312 else
4313 {
4317 }
4318 }
4319#endif
4320 }
4321
4322
4323
4325 {
4326
4327
4328
4330 {
4331
4334 }
4335 else
4336 {
4340 }
4341 }
4342
4343
4344
4346
4347
4348
4349
4350
4352
4353
4354
4355
4356 if ( 0)
4358
4359
4360
4366
4367
4368
4369
4370
4373
4374 for (;;)
4375 {
4378 {
4381 {
4384 break;
4385 }
4386 }
4387
4388
4391
4392
4398 }
4399
4401
4402
4403
4405
4408
4409
4410
4411
4412
4416
4417
4418
4419
4423
4424#if !defined(yyoverflow) || YYERROR_VERBOSE
4425
4426
4427
4431
4432#endif
4433
4438
4439
4443 {
4447 }
4448#ifndef yyoverflow
4451#endif
4452#if YYERROR_VERBOSE
4455#endif
4456
4458}
idhdl get(const char *s, int lev)
Class used for (list of) interpreter objects.
static FORCE_INLINE const char * n_Read(const char *s, number *a, const coeffs r)
!!! Recommendation: This method is too cryptic to be part of the user- !!! interface....
const CanonicalForm int s
const Variable & v
< [in] a sqrfree bivariate poly
char name(const Variable &v)
void WerrorS(const char *s)
EXTERN_VAR char prompt_char
BOOLEAN exitBuffer(feBufferTypes typ)
void newBuffer(char *s, feBufferTypes t, procinfo *pi, int lineno)
BOOLEAN contBuffer(feBufferTypes typ)
BOOLEAN newFile(char *fname)
int iiTestConvert(int inputType, int outputType)
const char * iiTwoOps(int t)
static const yytype_uint8 yyr1[]
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
static const yytype_int16 yydefgoto[]
#define YY_REDUCE_PRINT(Rule)
static const yytype_int16 yypact[]
static const yytype_int16 yypgoto[]
static void yydestruct(const char *yymsg, int yytype, YYSTYPE *yyvaluep)
#define YY_STACK_PRINT(Bottom, Top)
#define YYSTACK_ALLOC_MAXIMUM
void yyerror(const char *fmt)
BOOLEAN yyInRingConstruction
static const yytype_int16 yytable[]
static const yytype_uint8 yyr2[]
static const yytype_uint8 yystos[]
static const yytype_int16 yycheck[]
static const yytype_uint8 yydefact[]
#define idDelete(H)
delete an ideal
BOOLEAN jjLOAD(const char *s, BOOLEAN autoexport)
load lib/module given in v
BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
BOOLEAN iiExprArith1(leftv res, leftv a, int op)
BOOLEAN iiExprArithM(leftv res, leftv a, int op)
BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
BOOLEAN iiAssign(leftv l, leftv r, BOOLEAN toplevel)
BOOLEAN iiConvert(int inputType, int outputType, int index, leftv input, leftv output, const struct sConvertTypes *dConvertTypes)
void killhdl2(idhdl h, idhdl *ih, ring r)
idhdl enterid(const char *s, int lev, int t, idhdl *root, BOOLEAN init, BOOLEAN search)
void killhdl(idhdl h, package proot)
EXTERN_VAR omBin sleftv_bin
char * iiProcArgs(char *e, BOOLEAN withParenth)
INST_VAR sleftv iiRETURNEXPR
procinfo * iiInitSingularProcinfo(procinfov pi, const char *libname, const char *procname, int, long pos, BOOLEAN pstatic)
BOOLEAN iiParameter(leftv p)
int iiDeclCommand(leftv sy, leftv name, int lev, int t, idhdl *root, BOOLEAN isring, BOOLEAN init_b)
BOOLEAN iiApply(leftv res, leftv a, int op, leftv proc)
void list_cmd(int typ, const char *what, const char *prefix, BOOLEAN iterate, BOOLEAN fullname)
ring rInit(leftv pn, leftv rv, leftv ord)
BOOLEAN iiARROW(leftv r, char *a, char *s)
int exprlist_length(leftv v)
BOOLEAN iiTestAssume(leftv a, leftv b)
void iiSetReturn(const leftv source)
BOOLEAN iiAssignCR(leftv r, leftv arg)
idhdl rFindHdl(ring r, idhdl n)
const char * lastreserved
BOOLEAN iiExport(leftv v, int toLev)
void singular_example(char *str)
matrix mpNew(int r, int c)
create a r x c zero-matrix
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
void Werror(const char *fmt,...)
rRingOrder_t rOrderName(char *ordername)
ring rDefault(const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl, unsigned long bitmask)
ideal idInit(int idsize, int rank)
initialise an ideal / module
EXTERN_VAR YYSTYPE yylval
void syMake(leftv v, const char *id, package pa)
INST_VAR sleftv sLastPrinted
void syMakeMonom(leftv v, const char *id)
void writeRTime(const char *v)
void writeTime(const char *v)