2156{
2157
2159
2160
2162
2163
2165
2166 int yystate;
2167
2168 int yyerrstatus;
2169
2170
2171
2172
2173
2174
2175
2176
2177
2181
2182
2186
2188
2189 int yyn;
2190 int yyresult;
2191
2192 int yytoken;
2193
2194
2196
2197#if YYERROR_VERBOSE
2198
2199 char yymsgbuf[128];
2200 char *yymsg = yymsgbuf;
2201 YYSIZE_T yymsg_alloc =
sizeof yymsgbuf;
2202#endif
2203
2204#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
2205
2206
2207
2208 int yylen = 0;
2209
2210 yytoken = 0;
2211 yyss = yyssa;
2212 yyvs = yyvsa;
2214
2215 YYDPRINTF ((stderr,
"Starting parse\n"));
2216
2217 yystate = 0;
2218 yyerrstatus = 0;
2221
2222
2223
2224
2225
2226 yyssp = yyss;
2227 yyvsp = yyvs;
2228
2229 goto yysetstate;
2230
2231
2232
2233
2234 yynewstate:
2235
2236
2237 yyssp++;
2238
2239 yysetstate:
2240 *yyssp = yystate;
2241
2242 if (yyss + yystacksize - 1 <= yyssp)
2243 {
2244
2245 YYSIZE_T yysize = yyssp - yyss + 1;
2246
2247#ifdef yyoverflow
2248 {
2249
2250
2251
2254
2255
2256
2257
2258
2259 yyoverflow (
YY_(
"memory exhausted"),
2260 &yyss1, yysize * sizeof (*yyssp),
2261 &yyvs1, yysize * sizeof (*yyvsp),
2262 &yystacksize);
2263
2264 yyss = yyss1;
2265 yyvs = yyvs1;
2266 }
2267#else
2268# ifndef YYSTACK_RELOCATE
2269 goto yyexhaustedlab;
2270# else
2271
2273 goto yyexhaustedlab;
2274 yystacksize *= 2;
2277
2278 {
2280 union yyalloc *yyptr =
2281 (
union yyalloc *)
YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2282 if (! yyptr)
2283 goto yyexhaustedlab;
2284 YYSTACK_RELOCATE (yyss_alloc, yyss);
2285 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2286# undef YYSTACK_RELOCATE
2287 if (yyss1 != yyssa)
2289 }
2290# endif
2291#endif
2292
2293 yyssp = yyss + yysize - 1;
2294 yyvsp = yyvs + yysize - 1;
2295
2296 YYDPRINTF ((stderr,
"Stack size increased to %lu\n",
2297 (unsigned long int) yystacksize));
2298
2299 if (yyss + yystacksize - 1 <= yyssp)
2301 }
2302
2303 YYDPRINTF ((stderr,
"Entering state %d\n", yystate));
2304
2307
2308 goto yybackup;
2309
2310
2311
2312
2313yybackup:
2314
2315
2316
2317
2318
2321 goto yydefault;
2322
2323
2324
2325
2327 {
2328 YYDPRINTF ((stderr,
"Reading a token: "));
2330 }
2331
2333 {
2335 YYDPRINTF ((stderr,
"Now at end of input.\n"));
2336 }
2337 else
2338 {
2341 }
2342
2343
2344
2345 yyn += yytoken;
2347 goto yydefault;
2349 if (yyn <= 0)
2350 {
2352 goto yyerrlab;
2353 yyn = -yyn;
2354 goto yyreduce;
2355 }
2356
2357
2358
2359 if (yyerrstatus)
2360 yyerrstatus--;
2361
2362
2364
2365
2367
2368 yystate = yyn;
2370
2371 goto yynewstate;
2372
2373
2374
2375
2376
2377yydefault:
2379 if (yyn == 0)
2380 goto yyerrlab;
2381 goto yyreduce;
2382
2383
2384
2385
2386
2387yyreduce:
2388
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399 yyval = yyvsp[1-yylen];
2400
2401
2403 switch (yyn)
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"
2452 { (yyvsp[(1) - (2)].lv).CleanUp();
currentVoice->ifsw=0;;}
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
2494 if ((
inerror!=3) && ((yyvsp[(1) - (2)].
i)<
UMINUS) && ((yyvsp[(1) - (2)].
i)>
' '))
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 {
2573 syMake(&(yyval.lv),(yyvsp[(1) - (1)].name));
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 {
2591 if(
iiExprArith2(&(yyval.lv), &(yyvsp[(1) - (3)].lv),
'.', &(yyvsp[(3) - (3)].lv)))
YYERROR;
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 {
2609 if ((yyvsp[(1) - (4)].lv).
next==
NULL)
2610 {
2612 memcpy((yyvsp[(1) - (4)].lv).
next,&(yyvsp[(3) - (4)].lv),
sizeof(
sleftv));
2614 }
2615 else if ((yyvsp[(1) - (4)].lv).rtyp==
UNKNOWN)
2616 {
2618 }
2620 ;}
2621 break;
2622
2623 case 36:
2624
2625
2626#line 490 "grammar.y"
2627 {
2630 memset(&(yyval.lv),0,
sizeof(
sleftv));
2632 leftv v = &(yyvsp[(2) - (3)].lv);
2634 {
2637 memset(&tmp,0,sizeof(tmp));
2640 {
2641 pDelete((poly *)&(yyval.lv).data);
2642 (yyvsp[(2) - (3)].lv).CleanUp();
2644 }
2647 (yyval.lv).data = (
void *)
pAdd((poly)(yyval.lv).data,
p);
2651 }
2652 (yyvsp[(2) - (3)].lv).CleanUp();
2653 ;}
2654 break;
2655
2656 case 37:
2657
2658
2659#line 518 "grammar.y"
2660 {
2661 memset(&(yyval.lv),0,sizeof((yyval.lv)));
2662 int i = atoi((yyvsp[(1) - (1)].
name));
2663
2664
2666 (yyval.lv).data = (
void *)(long)
i;
2667
2668
2669 int l = strlen((yyvsp[(1) - (1)].
name))+2;
2670 number n;
2672 {
2675 if (strcmp(tmp,(yyvsp[(1) - (1)].
name))!=0)
2676 {
2679 (yyval.lv).data = n;
2680 }
2681 }
2682 ;}
2683 break;
2684
2685 case 38:
2686
2687
2688#line 542 "grammar.y"
2689 {
2690 memset(&(yyval.lv),0,sizeof((yyval.lv)));
2691 (yyval.lv).rtyp = (yyvsp[(1) - (1)].
i);
2692 (yyval.lv).data = (yyval.lv).Data();
2693 ;}
2694 break;
2695
2696 case 39:
2697
2698
2699#line 548 "grammar.y"
2700 {
2701 memset(&(yyval.lv),0,sizeof((yyval.lv)));
2703 (yyval.lv).data = (yyvsp[(1) - (1)].
name);
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 {
2811 if(
iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),
TRUE))
YYERROR;
2812 ;}
2813 break;
2814
2815 case 52:
2816
2817
2818#line 602 "grammar.y"
2819 {
2820 if(
iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),
TRUE))
YYERROR;
2821 ;}
2822 break;
2823
2824 case 53:
2825
2826
2827#line 606 "grammar.y"
2828 {
2829 if(
iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),
TRUE))
YYERROR;
2830 ;}
2831 break;
2832
2833 case 54:
2834
2835
2836#line 610 "grammar.y"
2837 {
2838 if(
iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),
TRUE))
YYERROR;
2839 ;}
2840 break;
2841
2842 case 55:
2843
2844
2845#line 614 "grammar.y"
2846 {
2847 if(
iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv)))
YYERROR;
2848 ;}
2849 break;
2850
2851 case 56:
2852
2853
2854#line 618 "grammar.y"
2855 {
2856 if(
iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv)))
YYERROR;
2857 ;}
2858 break;
2859
2860 case 57:
2861
2862
2863#line 622 "grammar.y"
2864 {
2865 if(
iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv)))
YYERROR;
2866 ;}
2867 break;
2868
2869 case 58:
2870
2871
2872#line 626 "grammar.y"
2873 {
2874 if(
iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv)))
YYERROR;
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 {
2892 int b=
iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i));
2895 ;}
2896 break;
2897
2898 case 61:
2899
2900
2901#line 640 "grammar.y"
2902 {
2903 if(
iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv)))
YYERROR;
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 {
2939 if (
iiARROW(&(yyval.lv),(yyvsp[(1) - (3)].name),(yyvsp[(3) - (3)].name)))
YYERROR;
2941 ;}
2942 break;
2943
2944 case 66:
2945
2946
2947#line 660 "grammar.y"
2948 { (yyval.lv) = (yyvsp[(2) - (3)].lv); ;}
2949 break;
2950
2951 case 67:
2952
2953
2954#line 665 "grammar.y"
2955 {
2956 leftv v = &(yyvsp[(1) - (3)].lv);
2957 while (
v->next!=
NULL)
2958 {
2960 }
2962 memcpy(
v->next,&((yyvsp[(3) - (3)].lv)),
sizeof(
sleftv));
2963 (yyval.lv) = (yyvsp[(1) - (3)].lv);
2964 ;}
2965 break;
2966
2967 case 71:
2968
2969
2970#line 681 "grammar.y"
2971 {
2972 if(
iiExprArith3(&(yyval.lv),
'[',&(yyvsp[(1) - (6)].lv),&(yyvsp[(3) - (6)].lv),&(yyvsp[(5) - (6)].lv)))
YYERROR;
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 {
2990 if (
iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i),
NULL))
YYERROR;
2991 ;}
2992 break;
2993
2994 case 74:
2995
2996
2997#line 693 "grammar.y"
2998 {
2999 if (
iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i),
NULL))
YYERROR;
3000 ;}
3001 break;
3002
3003 case 75:
3004
3005
3006#line 697 "grammar.y"
3007 {
3008 if (
iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i),
NULL))
YYERROR;
3009 ;}
3010 break;
3011
3012 case 76:
3013
3014
3015#line 701 "grammar.y"
3016 {
3017 if (
iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i),
NULL))
YYERROR;
3018 ;}
3019 break;
3020
3021 case 77:
3022
3023
3024#line 705 "grammar.y"
3025 {
3026 if (
iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i),
NULL))
YYERROR;
3027 ;}
3028 break;
3029
3030 case 78:
3031
3032
3033#line 709 "grammar.y"
3034 {
3035 if (
iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), 0, &(yyvsp[(5) - (6)].lv)))
YYERROR;
3036 ;}
3037 break;
3038
3039 case 79:
3040
3041
3042#line 713 "grammar.y"
3043 {
3044 (yyval.lv)=(yyvsp[(2) - (3)].lv);
3045 ;}
3046 break;
3047
3048 case 80:
3049
3050
3051#line 717 "grammar.y"
3052 {
3053 #ifdef SIQ
3056 {
if (
iiExprArith2(&(yyval.lv),&(yyvsp[(2) - (5)].lv),
'=',&(yyvsp[(4) - (5)].lv)))
YYERROR; }
3057 else
3058 #endif
3059 {
3060 memset(&(yyval.lv),0,sizeof((yyval.lv)));
3061 (yyval.lv).rtyp=
NONE;
3063 }
3064 #ifdef SIQ
3066 #endif
3067 ;}
3068 break;
3069
3070 case 81:
3071
3072
3073#line 734 "grammar.y"
3074 {
3075 iiTestAssume(&(yyvsp[(2) - (5)].lv),&(yyvsp[(4) - (5)].lv));
3076 memset(&(yyval.lv),0,sizeof((yyval.lv)));
3077 (yyval.lv).rtyp=
NONE;
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
3100 (yyval.lv)=(yyvsp[(4) - (5)].lv);
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 {
3181 if(
iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv)))
YYERROR;
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 {
3199 if(
iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv)))
YYERROR;
3200 ;}
3201 break;
3202
3203 case 94:
3204
3205
3206#line 811 "grammar.y"
3207 {
3208 if(
iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv)))
YYERROR;
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 {
3257 memset(&(yyval.lv),0,sizeof((yyval.lv)));
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 }
3284 else if (((yyvsp[(1) - (2)].lv).rtyp==
MODUL_CMD)
3285
3286 && ((yyvsp[(1) - (2)].lv).e!=
NULL) && ((yyvsp[(1) - (2)].lv).e->next==
NULL))
3287 {
3288 MYYERROR(
"matrix must have 2 indices");
3289 }
3290 (yyval.lv) = (yyvsp[(1) - (2)].lv);
3291 ;}
3292 break;
3293
3294 case 104:
3295
3296
3297#line 871 "grammar.y"
3298 {
3300 {
3301 MYYERROR(
"string expression expected");
3302 }
3303 (yyval.name) = (
char *)(yyvsp[(2) - (3)].lv).CopyD(
STRING_CMD);
3304 (yyvsp[(2) - (3)].lv).CleanUp();
3305 ;}
3306 break;
3307
3308 case 105:
3309
3310
3311#line 883 "grammar.y"
3312 {
3313 if (
iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),
myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3315 ;}
3316 break;
3317
3318 case 106:
3319
3320
3321#line 888 "grammar.y"
3322 {
3323 if (
iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),
myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
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 {
3369 if (
iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),
myynest,(yyvsp[(1) - (8)].i),&((yyvsp[(2) - (8)].lv).req_packhdl->idroot)))
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 {
3399 if (
iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),
myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
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();
3424 memset(&r,0,
sizeof(
sleftv));
3426 {
3429 }
3430 else
3431 {
3432 if (
iiDeclCommand(&r,&(yyvsp[(3) - (3)].lv),
myynest,t,&((yyvsp[(3) - (3)].lv).req_packhdl->idroot)))
3434 }
3435 leftv v=&(yyvsp[(1) - (3)].lv);
3436 while (
v->next!=
NULL)
v=
v->next;
3438 memcpy(
v->next,&r,
sizeof(
sleftv));
3439 (yyval.lv)=(yyvsp[(1) - (3)].lv);
3440 ;}
3441 break;
3442
3443 case 112:
3444
3445
3446#line 983 "grammar.y"
3447 {
3448 if (
iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),
myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3450 ;}
3451 break;
3452
3453 case 115:
3454
3455
3456#line 996 "grammar.y"
3457 {
3458 leftv v = &(yyvsp[(2) - (5)].lv);
3459 while (
v->next!=
NULL)
3460 {
3462 }
3464 memcpy(
v->next,&((yyvsp[(4) - (5)].lv)),
sizeof(
sleftv));
3465 (yyval.lv) = (yyvsp[(2) - (5)].lv);
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 {
3484 memset(&(yyval.lv),0,sizeof((yyval.lv)));
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 {
3498 memset(&(yyval.lv),0,sizeof((yyval.lv)));
3499 leftv sl = &(yyvsp[(3) - (4)].lv);
3500 int slLength;
3501 {
3503 int l = 2 + slLength;
3505 (*iv)[0] = slLength;
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 {
3545 (yyval.lv) = (yyvsp[(1) - (3)].lv);
3547 memcpy((yyval.lv).next,&(yyvsp[(3) - (3)].lv),
sizeof(
sleftv));
3548 ;}
3549 break;
3550
3551 case 122:
3552
3553
3554#line 1083 "grammar.y"
3555 {
3556 (yyval.lv) = (yyvsp[(2) - (3)].lv);
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 {
3610 if (
basePack!=(yyvsp[(2) - (2)].lv).req_packhdl)
3611 {
3613 }
3614 else
3616 ;}
3617 break;
3618
3619 case 133:
3620
3621
3622#line 1144 "grammar.y"
3623 {
3624 leftv v=&(yyvsp[(2) - (2)].lv);
3626 {
3628 {
3629 Werror(
"`%s` is undefined in kill",
v->name);
3631 }
3633 }
3634 else
3635 {
3637 }
3638 ;}
3639 break;
3640
3641 case 134:
3642
3643
3644#line 1161 "grammar.y"
3645 {
3646 leftv v=&(yyvsp[(3) - (3)].lv);
3648 {
3650 {
3651 Werror(
"`%s` is undefined in kill",
v->name);
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 {
3732 list_cmd(0,(yyvsp[(3) - (4)].lv).Fullname(),
"// ",
TRUE);
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 {
3835 const char *ring_name = (yyvsp[(2) - (8)].lv).
name;
3837 rInit(&(yyvsp[(4) - (8)].lv),
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();
3847 if (newRingHdl!=
NULL)
3848 {
3850 }
3851 else
3852 {
3854 }
3855 }
3857 if (newRingHdl==
NULL)
3858 {
3860 }
3861 else
3862 {
3864 }
3865 ;}
3866 break;
3867
3868 case 153:
3869
3870
3871#line 1311 "grammar.y"
3872 {
3873 const char *ring_name = (yyvsp[(2) - (2)].lv).
name;
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 {
3898 memcpy((yyvsp[(4) - (7)].lv).
next,&(yyvsp[(6) - (7)].lv),
sizeof(
sleftv));
3899 memset(&(yyvsp[(6) - (7)].lv),0,
sizeof(
sleftv));
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();
3923 if (((yyvsp[(2) - (2)].lv).Typ()==
RING_CMD)
3924 && ((yyvsp[(2) - (2)].lv).rtyp==
IDHDL))
3925 {
3927 if ((yyvsp[(2) - (2)].lv).e!=
NULL)
h=
rFindHdl((ring)(yyvsp[(2) - (2)].lv).Data(),
NULL);
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 {
3990 type_cmd(&((yyvsp[(2) - (2)].lv)));
3991 ;}
3992 break;
3993
3994 case 161:
3995
3996
3997#line 1418 "grammar.y"
3998 {
3999
4000 #ifdef SIQ
4001 if ((yyvsp[(1) - (1)].lv).rtyp!=
COMMAND)
4002 {
4003 #endif
4004 if ((yyvsp[(1) - (1)].lv).Typ()==
UNKNOWN)
4005 {
4006 if ((yyvsp[(1) - (1)].lv).
name!=
NULL)
4007 {
4008 Werror(
"`%s` is undefined",(yyvsp[(1) - (1)].lv).
name);
4010 }
4012 }
4013 #ifdef SIQ
4014 }
4015 #endif
4017 (yyvsp[(1) - (1)].lv).CleanUp(
currRing);
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
4102 size_t len= strlen((yyvsp[(2) - (3)].
name)) + strlen((yyvsp[(3) - (3)].
name)) + 36;
4104 snprintf(
s,len,
"whileif (!(%s)) break;\n%scontinue;\n " ,(yyvsp[(2) - (3)].
name),(yyvsp[(3) - (3)].
name));
4108 ;}
4109 break;
4110
4111 case 168:
4112
4113
4114#line 1512 "grammar.y"
4115 {
4116
4117
4118 size_t len= strlen((yyvsp[(3) - (5)].
name))+strlen((yyvsp[(4) - (5)].
name))+strlen((yyvsp[(5) - (5)].
name))+36;
4120 snprintf(
s,len,
"forif (!(%s)) break;\n%s%s;\ncontinue;\n "
4121 ,(yyvsp[(3) - (5)].
name),(yyvsp[(5) - (5)].
name),(yyvsp[(4) - (5)].
name));
4126 len=strlen((yyvsp[(2) - (5)].
name)) + 3;
4128 snprintf(
s,len,
"%s;\n",(yyvsp[(2) - (5)].
name));
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 }
4165 IDPROC(
h)->data.s.body = (
char *)
omAlloc(strlen((yyvsp[(3) - (3)].
name))+strlen(args)+14);;
4166 sprintf(
IDPROC(
h)->data.s.body,
"%s\n%s;return();\n\n",args,(yyvsp[(3) - (3)].name));
4170 ;}
4171 break;
4172
4173 case 171:
4174
4175
4176#line 1562 "grammar.y"
4177 {
4181 {
4186 }
4191 IDPROC(
h)->data.s.body = (
char *)
omAlloc(strlen((yyvsp[(4) - (4)].
name))+strlen(args)+14);;
4192 sprintf(
IDPROC(
h)->data.s.body,
"%s\n%s;return();\n\n",args,(yyvsp[(4) - (4)].name));
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 {
4239 if ((yyvsp[(1) - (3)].
i)==
RETURN)
4240 {
4244 }
4245 ;}
4246 break;
4247
4248
4249
4250
4251#line 4252 "grammar.cc"
4252 default: break;
4253 }
4255
4257 yylen = 0;
4259
4260 *++yyvsp = yyval;
4261
4262
4263
4264
4265
4267
4269 if (0 <= yystate && yystate <=
YYLAST &&
yycheck[yystate] == *yyssp)
4271 else
4273
4274 goto yynewstate;
4275
4276
4277
4278
4279
4280yyerrlab:
4281
4282 if (!yyerrstatus)
4283 {
4285#if ! YYERROR_VERBOSE
4287#else
4288 {
4291 {
4295 if (yymsg != yymsgbuf)
4298 if (yymsg)
4299 yymsg_alloc = yyalloc;
4300 else
4301 {
4302 yymsg = yymsgbuf;
4303 yymsg_alloc = sizeof yymsgbuf;
4304 }
4305 }
4306
4307 if (0 < yysize && yysize <= yymsg_alloc)
4308 {
4309 (void) yysyntax_error (yymsg, yystate,
yychar);
4311 }
4312 else
4313 {
4315 if (yysize != 0)
4316 goto yyexhaustedlab;
4317 }
4318 }
4319#endif
4320 }
4321
4322
4323
4324 if (yyerrstatus == 3)
4325 {
4326
4327
4328
4330 {
4331
4334 }
4335 else
4336 {
4340 }
4341 }
4342
4343
4344
4345 goto yyerrlab1;
4346
4347
4348
4349
4350
4351yyerrorlab:
4352
4353
4354
4355
4356 if ( 0)
4357 goto yyerrorlab;
4358
4359
4360
4362 yylen = 0;
4364 yystate = *yyssp;
4365 goto yyerrlab1;
4366
4367
4368
4369
4370
4371yyerrlab1:
4372 yyerrstatus = 3;
4373
4374 for (;;)
4375 {
4378 {
4381 {
4383 if (0 < yyn)
4384 break;
4385 }
4386 }
4387
4388
4389 if (yyssp == yyss)
4391
4392
4396 yystate = *yyssp;
4398 }
4399
4401
4402
4403
4405
4406 yystate = yyn;
4407 goto yynewstate;
4408
4409
4410
4411
4412
4413yyacceptlab:
4414 yyresult = 0;
4415 goto yyreturn;
4416
4417
4418
4419
4420yyabortlab:
4421 yyresult = 1;
4422 goto yyreturn;
4423
4424#if !defined(yyoverflow) || YYERROR_VERBOSE
4425
4426
4427
4428yyexhaustedlab:
4430 yyresult = 2;
4431
4432#endif
4433
4434yyreturn:
4438
4439
4442 while (yyssp != yyss)
4443 {
4447 }
4448#ifndef yyoverflow
4449 if (yyss != yyssa)
4451#endif
4452#if YYERROR_VERBOSE
4453 if (yymsg != yymsgbuf)
4455#endif
4456
4457 return YYID (yyresult);
4458}
idhdl get(const char *s, int lev)
Class used for (list of) interpreter objects.
void CleanUp(ring r=currRing)
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
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)
int name
New type name for int.
void writeRTime(const char *v)
void writeTime(const char *v)