Fossil SCM

Update the built-in Pikchr source code and WASM/JS builds.

drh 2022-10-26 12:46 trunk

Commit 8f4a32ccaedf429d6db0a54b6ab3423cb0cd6cc8ce10b76c35947910bd1542b1

Parent 4aa78375055222d…

3 files changed +166 -172 +139 -145

~ extsrc/pikchr.c ~ extsrc/pikchr.js ~ extsrc/pikchr.wasm

M extsrc/pikchr.c

+166 -172

		--- extsrc/pikchr.c
		+++ extsrc/pikchr.c
		@@ -1256,13 +1256,13 @@
1256	1256	yyStackEntry yystackEnd; / Last entry in the stack */
1257	1257	#endif
1258	1258	};
1259	1259	typedef struct yyParser yyParser;
1260	1260
1261		-#ifndef NDEBUG
1262		-#include <stdio.h>
1263	1261	#include <assert.h>
	1262	+#ifndef NDEBUG
	1263	+#include <stdio.h>
1264	1264	static FILE *yyTraceFILE = 0;
1265	1265	static char *yyTracePrompt = 0;
1266	1266	#endif /* NDEBUG */
1267	1267
1268	1268	#ifndef NDEBUG
		@@ -2368,59 +2368,10 @@
2368	2368	int yysize; /* Amount to pop the stack */
2369	2369	pik_parserARG_FETCH
2370	2370	(void)yyLookahead;
2371	2371	(void)yyLookaheadToken;
2372	2372	yymsp = yypParser->yytos;
2373		- assert( yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) );
2374		-#ifndef NDEBUG
2375		- if( yyTraceFILE ){
2376		- yysize = yyRuleInfoNRhs[yyruleno];
2377		- if( yysize ){
2378		- fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
2379		- yyTracePrompt,
2380		- yyruleno, yyRuleName[yyruleno],
2381		- yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action",
2382		- yymsp[yysize].stateno);
2383		- }else{
2384		- fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n",
2385		- yyTracePrompt, yyruleno, yyRuleName[yyruleno],
2386		- yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action");
2387		- }
2388		- }
2389		-#endif /* NDEBUG */
2390		-
2391		- /* Check that the stack is large enough to grow by a single entry
2392		- ** if the RHS of the rule is empty. This ensures that there is room
2393		- ** enough on the stack to push the LHS value */
2394		- if( yyRuleInfoNRhs[yyruleno]==0 ){
2395		-#ifdef YYTRACKMAXSTACKDEPTH
2396		- if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
2397		- yypParser->yyhwm++;
2398		- assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack));
2399		- }
2400		-#endif
2401		-#if YYSTACKDEPTH>0
2402		- if( yypParser->yytos>=yypParser->yystackEnd ){
2403		- yyStackOverflow(yypParser);
2404		- /* The call to yyStackOverflow() above pops the stack until it is
2405		- ** empty, causing the main parser loop to exit. So the return value
2406		- ** is never used and does not matter. */
2407		- return 0;
2408		- }
2409		-#else
2410		- if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){
2411		- if( yyGrowStack(yypParser) ){
2412		- yyStackOverflow(yypParser);
2413		- /* The call to yyStackOverflow() above pops the stack until it is
2414		- ** empty, causing the main parser loop to exit. So the return value
2415		- ** is never used and does not matter. */
2416		- return 0;
2417		- }
2418		- yymsp = yypParser->yytos;
2419		- }
2420		-#endif
2421		- }
2422	2373
2423	2374	switch( yyruleno ){
2424	2375	/* Beginning here are the reduction cases. A typical example
2425	2376	** follows:
2426	2377	** case 0:
		@@ -2432,617 +2383,617 @@
2432	2383	/******** Begin reduce actions ********************************************/
2433	2384	YYMINORTYPE yylhsminor;
2434	2385	case 0: /* document ::= statement_list */
2435	2386	#line 547 "pikchr.y"
2436	2387	{pik_render(p,yymsp[0].minor.yy227);}
2437		-#line 2462 "pikchr.c"
	2388	+#line 2413 "pikchr.c"
2438	2389	break;
2439	2390	case 1: /* statement_list ::= statement */
2440	2391	#line 550 "pikchr.y"
2441	2392	{ yylhsminor.yy227 = pik_elist_append(p,0,yymsp[0].minor.yy36); }
2442		-#line 2467 "pikchr.c"
	2393	+#line 2418 "pikchr.c"
2443	2394	yymsp[0].minor.yy227 = yylhsminor.yy227;
2444	2395	break;
2445	2396	case 2: /* statement_list ::= statement_list EOL statement */
2446	2397	#line 552 "pikchr.y"
2447	2398	{ yylhsminor.yy227 = pik_elist_append(p,yymsp[-2].minor.yy227,yymsp[0].minor.yy36); }
2448		-#line 2473 "pikchr.c"
	2399	+#line 2424 "pikchr.c"
2449	2400	yymsp[-2].minor.yy227 = yylhsminor.yy227;
2450	2401	break;
2451	2402	case 3: /* statement ::= */
2452	2403	#line 555 "pikchr.y"
2453	2404	{ yymsp[1].minor.yy36 = 0; }
2454		-#line 2479 "pikchr.c"
	2405	+#line 2430 "pikchr.c"
2455	2406	break;
2456	2407	case 4: /* statement ::= direction */
2457	2408	#line 556 "pikchr.y"
2458	2409	{ pik_set_direction(p,yymsp[0].minor.yy0.eCode); yylhsminor.yy36=0; }
2459		-#line 2484 "pikchr.c"
	2410	+#line 2435 "pikchr.c"
2460	2411	yymsp[0].minor.yy36 = yylhsminor.yy36;
2461	2412	break;
2462	2413	case 5: /* statement ::= lvalue ASSIGN rvalue */
2463	2414	#line 557 "pikchr.y"
2464	2415	{pik_set_var(p,&yymsp[-2].minor.yy0,yymsp[0].minor.yy153,&yymsp[-1].minor.yy0); yylhsminor.yy36=0;}
2465		-#line 2490 "pikchr.c"
	2416	+#line 2441 "pikchr.c"
2466	2417	yymsp[-2].minor.yy36 = yylhsminor.yy36;
2467	2418	break;
2468	2419	case 6: /* statement ::= PLACENAME COLON unnamed_statement */
2469	2420	#line 559 "pikchr.y"
2470	2421	{ yylhsminor.yy36 = yymsp[0].minor.yy36; pik_elem_setname(p,yymsp[0].minor.yy36,&yymsp[-2].minor.yy0); }
2471		-#line 2496 "pikchr.c"
	2422	+#line 2447 "pikchr.c"
2472	2423	yymsp[-2].minor.yy36 = yylhsminor.yy36;
2473	2424	break;
2474	2425	case 7: /* statement ::= PLACENAME COLON position */
2475	2426	#line 561 "pikchr.y"
2476	2427	{ yylhsminor.yy36 = pik_elem_new(p,0,0,0);
2477	2428	if(yylhsminor.yy36){ yylhsminor.yy36->ptAt = yymsp[0].minor.yy79; pik_elem_setname(p,yylhsminor.yy36,&yymsp[-2].minor.yy0); }}
2478		-#line 2503 "pikchr.c"
	2429	+#line 2454 "pikchr.c"
2479	2430	yymsp[-2].minor.yy36 = yylhsminor.yy36;
2480	2431	break;
2481	2432	case 8: /* statement ::= unnamed_statement */
2482	2433	#line 563 "pikchr.y"
2483	2434	{yylhsminor.yy36 = yymsp[0].minor.yy36;}
2484		-#line 2509 "pikchr.c"
	2435	+#line 2460 "pikchr.c"
2485	2436	yymsp[0].minor.yy36 = yylhsminor.yy36;
2486	2437	break;
2487	2438	case 9: /* statement ::= print prlist */
2488	2439	#line 564 "pikchr.y"
2489	2440	{pik_append(p,"<br>\n",5); yymsp[-1].minor.yy36=0;}
2490		-#line 2515 "pikchr.c"
	2441	+#line 2466 "pikchr.c"
2491	2442	break;
2492	2443	case 10: /* statement ::= ASSERT LP expr EQ expr RP */
2493	2444	#line 569 "pikchr.y"
2494	2445	{yymsp[-5].minor.yy36=pik_assert(p,yymsp[-3].minor.yy153,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy153);}
2495		-#line 2520 "pikchr.c"
	2446	+#line 2471 "pikchr.c"
2496	2447	break;
2497	2448	case 11: /* statement ::= ASSERT LP position EQ position RP */
2498	2449	#line 571 "pikchr.y"
2499	2450	{yymsp[-5].minor.yy36=pik_position_assert(p,&yymsp[-3].minor.yy79,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy79);}
2500		-#line 2525 "pikchr.c"
	2451	+#line 2476 "pikchr.c"
2501	2452	break;
2502	2453	case 12: /* statement ::= DEFINE ID CODEBLOCK */
2503	2454	#line 572 "pikchr.y"
2504	2455	{yymsp[-2].minor.yy36=0; pik_add_macro(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
2505		-#line 2530 "pikchr.c"
	2456	+#line 2481 "pikchr.c"
2506	2457	break;
2507	2458	case 13: /* rvalue ::= PLACENAME */
2508	2459	#line 583 "pikchr.y"
2509	2460	{yylhsminor.yy153 = pik_lookup_color(p,&yymsp[0].minor.yy0);}
2510		-#line 2535 "pikchr.c"
	2461	+#line 2486 "pikchr.c"
2511	2462	yymsp[0].minor.yy153 = yylhsminor.yy153;
2512	2463	break;
2513	2464	case 14: /* pritem ::= FILL */
2514	2465	case 15: /* pritem ::= COLOR */ yytestcase(yyruleno==15);
2515	2466	case 16: /* pritem ::= THICKNESS */ yytestcase(yyruleno==16);
2516	2467	#line 588 "pikchr.y"
2517	2468	{pik_append_num(p,"",pik_value(p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.n,0));}
2518		-#line 2543 "pikchr.c"
	2469	+#line 2494 "pikchr.c"
2519	2470	break;
2520	2471	case 17: /* pritem ::= rvalue */
2521	2472	#line 591 "pikchr.y"
2522	2473	{pik_append_num(p,"",yymsp[0].minor.yy153);}
2523		-#line 2548 "pikchr.c"
	2474	+#line 2499 "pikchr.c"
2524	2475	break;
2525	2476	case 18: /* pritem ::= STRING */
2526	2477	#line 592 "pikchr.y"
2527	2478	{pik_append_text(p,yymsp[0].minor.yy0.z+1,yymsp[0].minor.yy0.n-2,0);}
2528		-#line 2553 "pikchr.c"
	2479	+#line 2504 "pikchr.c"
2529	2480	break;
2530	2481	case 19: /* prsep ::= COMMA */
2531	2482	#line 593 "pikchr.y"
2532	2483	{pik_append(p, " ", 1);}
2533		-#line 2558 "pikchr.c"
	2484	+#line 2509 "pikchr.c"
2534	2485	break;
2535	2486	case 20: /* unnamed_statement ::= basetype attribute_list */
2536	2487	#line 596 "pikchr.y"
2537	2488	{yylhsminor.yy36 = yymsp[-1].minor.yy36; pik_after_adding_attributes(p,yylhsminor.yy36);}
2538		-#line 2563 "pikchr.c"
	2489	+#line 2514 "pikchr.c"
2539	2490	yymsp[-1].minor.yy36 = yylhsminor.yy36;
2540	2491	break;
2541	2492	case 21: /* basetype ::= CLASSNAME */
2542	2493	#line 598 "pikchr.y"
2543	2494	{yylhsminor.yy36 = pik_elem_new(p,&yymsp[0].minor.yy0,0,0); }
2544		-#line 2569 "pikchr.c"
	2495	+#line 2520 "pikchr.c"
2545	2496	yymsp[0].minor.yy36 = yylhsminor.yy36;
2546	2497	break;
2547	2498	case 22: /* basetype ::= STRING textposition */
2548	2499	#line 600 "pikchr.y"
2549	2500	{yymsp[-1].minor.yy0.eCode = yymsp[0].minor.yy164; yylhsminor.yy36 = pik_elem_new(p,0,&yymsp[-1].minor.yy0,0); }
2550		-#line 2575 "pikchr.c"
	2501	+#line 2526 "pikchr.c"
2551	2502	yymsp[-1].minor.yy36 = yylhsminor.yy36;
2552	2503	break;
2553	2504	case 23: /* basetype ::= LB savelist statement_list RB */
2554	2505	#line 602 "pikchr.y"
2555	2506	{ p->list = yymsp[-2].minor.yy227; yymsp[-3].minor.yy36 = pik_elem_new(p,0,0,yymsp[-1].minor.yy227); if(yymsp[-3].minor.yy36) yymsp[-3].minor.yy36->errTok = yymsp[0].minor.yy0; }
2556		-#line 2581 "pikchr.c"
	2507	+#line 2532 "pikchr.c"
2557	2508	break;
2558	2509	case 24: /* savelist ::= */
2559	2510	#line 607 "pikchr.y"
2560	2511	{yymsp[1].minor.yy227 = p->list; p->list = 0;}
2561		-#line 2586 "pikchr.c"
	2512	+#line 2537 "pikchr.c"
2562	2513	break;
2563	2514	case 25: /* relexpr ::= expr */
2564	2515	#line 614 "pikchr.y"
2565	2516	{yylhsminor.yy10.rAbs = yymsp[0].minor.yy153; yylhsminor.yy10.rRel = 0;}
2566		-#line 2591 "pikchr.c"
	2517	+#line 2542 "pikchr.c"
2567	2518	yymsp[0].minor.yy10 = yylhsminor.yy10;
2568	2519	break;
2569	2520	case 26: /* relexpr ::= expr PERCENT */
2570	2521	#line 615 "pikchr.y"
2571	2522	{yylhsminor.yy10.rAbs = 0; yylhsminor.yy10.rRel = yymsp[-1].minor.yy153/100;}
2572		-#line 2597 "pikchr.c"
	2523	+#line 2548 "pikchr.c"
2573	2524	yymsp[-1].minor.yy10 = yylhsminor.yy10;
2574	2525	break;
2575	2526	case 27: /* optrelexpr ::= */
2576	2527	#line 617 "pikchr.y"
2577	2528	{yymsp[1].minor.yy10.rAbs = 0; yymsp[1].minor.yy10.rRel = 1.0;}
2578		-#line 2603 "pikchr.c"
	2529	+#line 2554 "pikchr.c"
2579	2530	break;
2580	2531	case 28: /* attribute_list ::= relexpr alist */
2581	2532	#line 619 "pikchr.y"
2582	2533	{pik_add_direction(p,0,&yymsp[-1].minor.yy10);}
2583		-#line 2608 "pikchr.c"
	2534	+#line 2559 "pikchr.c"
2584	2535	break;
2585	2536	case 29: /* attribute ::= numproperty relexpr */
2586	2537	#line 623 "pikchr.y"
2587	2538	{ pik_set_numprop(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy10); }
2588		-#line 2613 "pikchr.c"
	2539	+#line 2564 "pikchr.c"
2589	2540	break;
2590	2541	case 30: /* attribute ::= dashproperty expr */
2591	2542	#line 624 "pikchr.y"
2592	2543	{ pik_set_dashed(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy153); }
2593		-#line 2618 "pikchr.c"
	2544	+#line 2569 "pikchr.c"
2594	2545	break;
2595	2546	case 31: /* attribute ::= dashproperty */
2596	2547	#line 625 "pikchr.y"
2597	2548	{ pik_set_dashed(p,&yymsp[0].minor.yy0,0); }
2598		-#line 2623 "pikchr.c"
	2549	+#line 2574 "pikchr.c"
2599	2550	break;
2600	2551	case 32: /* attribute ::= colorproperty rvalue */
2601	2552	#line 626 "pikchr.y"
2602	2553	{ pik_set_clrprop(p,&yymsp[-1].minor.yy0,yymsp[0].minor.yy153); }
2603		-#line 2628 "pikchr.c"
	2554	+#line 2579 "pikchr.c"
2604	2555	break;
2605	2556	case 33: /* attribute ::= go direction optrelexpr */
2606	2557	#line 627 "pikchr.y"
2607	2558	{ pik_add_direction(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy10);}
2608		-#line 2633 "pikchr.c"
	2559	+#line 2584 "pikchr.c"
2609	2560	break;
2610	2561	case 34: /* attribute ::= go direction even position */
2611	2562	#line 628 "pikchr.y"
2612	2563	{pik_evenwith(p,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy79);}
2613		-#line 2638 "pikchr.c"
	2564	+#line 2589 "pikchr.c"
2614	2565	break;
2615	2566	case 35: /* attribute ::= CLOSE */
2616	2567	#line 629 "pikchr.y"
2617	2568	{ pik_close_path(p,&yymsp[0].minor.yy0); }
2618		-#line 2643 "pikchr.c"
	2569	+#line 2594 "pikchr.c"
2619	2570	break;
2620	2571	case 36: /* attribute ::= CHOP */
2621	2572	#line 630 "pikchr.y"
2622	2573	{ p->cur->bChop = 1; }
2623		-#line 2648 "pikchr.c"
	2574	+#line 2599 "pikchr.c"
2624	2575	break;
2625	2576	case 37: /* attribute ::= FROM position */
2626	2577	#line 631 "pikchr.y"
2627	2578	{ pik_set_from(p,p->cur,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy79); }
2628		-#line 2653 "pikchr.c"
	2579	+#line 2604 "pikchr.c"
2629	2580	break;
2630	2581	case 38: /* attribute ::= TO position */
2631	2582	#line 632 "pikchr.y"
2632	2583	{ pik_add_to(p,p->cur,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy79); }
2633		-#line 2658 "pikchr.c"
	2584	+#line 2609 "pikchr.c"
2634	2585	break;
2635	2586	case 39: /* attribute ::= THEN */
2636	2587	#line 633 "pikchr.y"
2637	2588	{ pik_then(p, &yymsp[0].minor.yy0, p->cur); }
2638		-#line 2663 "pikchr.c"
	2589	+#line 2614 "pikchr.c"
2639	2590	break;
2640	2591	case 40: /* attribute ::= THEN optrelexpr HEADING expr */
2641	2592	case 42: /* attribute ::= GO optrelexpr HEADING expr */ yytestcase(yyruleno==42);
2642	2593	#line 635 "pikchr.y"
2643	2594	{pik_move_hdg(p,&yymsp[-2].minor.yy10,&yymsp[-1].minor.yy0,yymsp[0].minor.yy153,0,&yymsp[-3].minor.yy0);}
2644		-#line 2669 "pikchr.c"
	2595	+#line 2620 "pikchr.c"
2645	2596	break;
2646	2597	case 41: /* attribute ::= THEN optrelexpr EDGEPT */
2647	2598	case 43: /* attribute ::= GO optrelexpr EDGEPT */ yytestcase(yyruleno==43);
2648	2599	#line 636 "pikchr.y"
2649	2600	{pik_move_hdg(p,&yymsp[-1].minor.yy10,0,0,&yymsp[0].minor.yy0,&yymsp[-2].minor.yy0);}
2650		-#line 2675 "pikchr.c"
	2601	+#line 2626 "pikchr.c"
2651	2602	break;
2652	2603	case 44: /* attribute ::= AT position */
2653	2604	#line 641 "pikchr.y"
2654	2605	{ pik_set_at(p,0,&yymsp[0].minor.yy79,&yymsp[-1].minor.yy0); }
2655		-#line 2680 "pikchr.c"
	2606	+#line 2631 "pikchr.c"
2656	2607	break;
2657	2608	case 45: /* attribute ::= SAME */
2658	2609	#line 643 "pikchr.y"
2659	2610	{pik_same(p,0,&yymsp[0].minor.yy0);}
2660		-#line 2685 "pikchr.c"
	2611	+#line 2636 "pikchr.c"
2661	2612	break;
2662	2613	case 46: /* attribute ::= SAME AS object */
2663	2614	#line 644 "pikchr.y"
2664	2615	{pik_same(p,yymsp[0].minor.yy36,&yymsp[-2].minor.yy0);}
2665		-#line 2690 "pikchr.c"
	2616	+#line 2641 "pikchr.c"
2666	2617	break;
2667	2618	case 47: /* attribute ::= STRING textposition */
2668	2619	#line 645 "pikchr.y"
2669	2620	{pik_add_txt(p,&yymsp[-1].minor.yy0,yymsp[0].minor.yy164);}
2670		-#line 2695 "pikchr.c"
	2621	+#line 2646 "pikchr.c"
2671	2622	break;
2672	2623	case 48: /* attribute ::= FIT */
2673	2624	#line 646 "pikchr.y"
2674	2625	{pik_size_to_fit(p,&yymsp[0].minor.yy0,3); }
2675		-#line 2700 "pikchr.c"
	2626	+#line 2651 "pikchr.c"
2676	2627	break;
2677	2628	case 49: /* attribute ::= BEHIND object */
2678	2629	#line 647 "pikchr.y"
2679	2630	{pik_behind(p,yymsp[0].minor.yy36);}
2680		-#line 2705 "pikchr.c"
	2631	+#line 2656 "pikchr.c"
2681	2632	break;
2682	2633	case 50: /* withclause ::= DOT_E edge AT position */
2683	2634	case 51: /* withclause ::= edge AT position */ yytestcase(yyruleno==51);
2684	2635	#line 655 "pikchr.y"
2685	2636	{ pik_set_at(p,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy79,&yymsp[-1].minor.yy0); }
2686		-#line 2711 "pikchr.c"
	2637	+#line 2662 "pikchr.c"
2687	2638	break;
2688	2639	case 52: /* numproperty ::= HEIGHT\|WIDTH\|RADIUS\|DIAMETER\|THICKNESS */
2689	2640	#line 659 "pikchr.y"
2690	2641	{yylhsminor.yy0 = yymsp[0].minor.yy0;}
2691		-#line 2716 "pikchr.c"
	2642	+#line 2667 "pikchr.c"
2692	2643	yymsp[0].minor.yy0 = yylhsminor.yy0;
2693	2644	break;
2694	2645	case 53: /* boolproperty ::= CW */
2695	2646	#line 670 "pikchr.y"
2696	2647	{p->cur->cw = 1;}
2697		-#line 2722 "pikchr.c"
	2648	+#line 2673 "pikchr.c"
2698	2649	break;
2699	2650	case 54: /* boolproperty ::= CCW */
2700	2651	#line 671 "pikchr.y"
2701	2652	{p->cur->cw = 0;}
2702		-#line 2727 "pikchr.c"
	2653	+#line 2678 "pikchr.c"
2703	2654	break;
2704	2655	case 55: /* boolproperty ::= LARROW */
2705	2656	#line 672 "pikchr.y"
2706	2657	{p->cur->larrow=1; p->cur->rarrow=0; }
2707		-#line 2732 "pikchr.c"
	2658	+#line 2683 "pikchr.c"
2708	2659	break;
2709	2660	case 56: /* boolproperty ::= RARROW */
2710	2661	#line 673 "pikchr.y"
2711	2662	{p->cur->larrow=0; p->cur->rarrow=1; }
2712		-#line 2737 "pikchr.c"
	2663	+#line 2688 "pikchr.c"
2713	2664	break;
2714	2665	case 57: /* boolproperty ::= LRARROW */
2715	2666	#line 674 "pikchr.y"
2716	2667	{p->cur->larrow=1; p->cur->rarrow=1; }
2717		-#line 2742 "pikchr.c"
	2668	+#line 2693 "pikchr.c"
2718	2669	break;
2719	2670	case 58: /* boolproperty ::= INVIS */
2720	2671	#line 675 "pikchr.y"
2721	2672	{p->cur->sw = 0.0;}
2722		-#line 2747 "pikchr.c"
	2673	+#line 2698 "pikchr.c"
2723	2674	break;
2724	2675	case 59: /* boolproperty ::= THICK */
2725	2676	#line 676 "pikchr.y"
2726	2677	{p->cur->sw *= 1.5;}
2727		-#line 2752 "pikchr.c"
	2678	+#line 2703 "pikchr.c"
2728	2679	break;
2729	2680	case 60: /* boolproperty ::= THIN */
2730	2681	#line 677 "pikchr.y"
2731	2682	{p->cur->sw *= 0.67;}
2732		-#line 2757 "pikchr.c"
	2683	+#line 2708 "pikchr.c"
2733	2684	break;
2734	2685	case 61: /* boolproperty ::= SOLID */
2735	2686	#line 678 "pikchr.y"
2736	2687	{p->cur->sw = pik_value(p,"thickness",9,0);
2737	2688	p->cur->dotted = p->cur->dashed = 0.0;}
2738		-#line 2763 "pikchr.c"
	2689	+#line 2714 "pikchr.c"
2739	2690	break;
2740	2691	case 62: /* textposition ::= */
2741	2692	#line 681 "pikchr.y"
2742	2693	{yymsp[1].minor.yy164 = 0;}
2743		-#line 2768 "pikchr.c"
	2694	+#line 2719 "pikchr.c"
2744	2695	break;
2745	2696	case 63: /* textposition ::= textposition CENTER\|LJUST\|RJUST\|ABOVE\|BELOW\|ITALIC\|BOLD\|ALIGNED\|BIG\|SMALL */
2746	2697	#line 684 "pikchr.y"
2747	2698	{yylhsminor.yy164 = (short int)pik_text_position(yymsp[-1].minor.yy164,&yymsp[0].minor.yy0);}
2748		-#line 2773 "pikchr.c"
	2699	+#line 2724 "pikchr.c"
2749	2700	yymsp[-1].minor.yy164 = yylhsminor.yy164;
2750	2701	break;
2751	2702	case 64: /* position ::= expr COMMA expr */
2752	2703	#line 687 "pikchr.y"
2753	2704	{yylhsminor.yy79.x=yymsp[-2].minor.yy153; yylhsminor.yy79.y=yymsp[0].minor.yy153;}
2754		-#line 2779 "pikchr.c"
	2705	+#line 2730 "pikchr.c"
2755	2706	yymsp[-2].minor.yy79 = yylhsminor.yy79;
2756	2707	break;
2757	2708	case 65: /* position ::= place PLUS expr COMMA expr */
2758	2709	#line 689 "pikchr.y"
2759	2710	{yylhsminor.yy79.x=yymsp[-4].minor.yy79.x+yymsp[-2].minor.yy153; yylhsminor.yy79.y=yymsp[-4].minor.yy79.y+yymsp[0].minor.yy153;}
2760		-#line 2785 "pikchr.c"
	2711	+#line 2736 "pikchr.c"
2761	2712	yymsp[-4].minor.yy79 = yylhsminor.yy79;
2762	2713	break;
2763	2714	case 66: /* position ::= place MINUS expr COMMA expr */
2764	2715	#line 690 "pikchr.y"
2765	2716	{yylhsminor.yy79.x=yymsp[-4].minor.yy79.x-yymsp[-2].minor.yy153; yylhsminor.yy79.y=yymsp[-4].minor.yy79.y-yymsp[0].minor.yy153;}
2766		-#line 2791 "pikchr.c"
	2717	+#line 2742 "pikchr.c"
2767	2718	yymsp[-4].minor.yy79 = yylhsminor.yy79;
2768	2719	break;
2769	2720	case 67: /* position ::= place PLUS LP expr COMMA expr RP */
2770	2721	#line 692 "pikchr.y"
2771	2722	{yylhsminor.yy79.x=yymsp[-6].minor.yy79.x+yymsp[-3].minor.yy153; yylhsminor.yy79.y=yymsp[-6].minor.yy79.y+yymsp[-1].minor.yy153;}
2772		-#line 2797 "pikchr.c"
	2723	+#line 2748 "pikchr.c"
2773	2724	yymsp[-6].minor.yy79 = yylhsminor.yy79;
2774	2725	break;
2775	2726	case 68: /* position ::= place MINUS LP expr COMMA expr RP */
2776	2727	#line 694 "pikchr.y"
2777	2728	{yylhsminor.yy79.x=yymsp[-6].minor.yy79.x-yymsp[-3].minor.yy153; yylhsminor.yy79.y=yymsp[-6].minor.yy79.y-yymsp[-1].minor.yy153;}
2778		-#line 2803 "pikchr.c"
	2729	+#line 2754 "pikchr.c"
2779	2730	yymsp[-6].minor.yy79 = yylhsminor.yy79;
2780	2731	break;
2781	2732	case 69: /* position ::= LP position COMMA position RP */
2782	2733	#line 695 "pikchr.y"
2783	2734	{yymsp[-4].minor.yy79.x=yymsp[-3].minor.yy79.x; yymsp[-4].minor.yy79.y=yymsp[-1].minor.yy79.y;}
2784		-#line 2809 "pikchr.c"
	2735	+#line 2760 "pikchr.c"
2785	2736	break;
2786	2737	case 70: /* position ::= LP position RP */
2787	2738	#line 696 "pikchr.y"
2788	2739	{yymsp[-2].minor.yy79=yymsp[-1].minor.yy79;}
2789		-#line 2814 "pikchr.c"
	2740	+#line 2765 "pikchr.c"
2790	2741	break;
2791	2742	case 71: /* position ::= expr between position AND position */
2792	2743	#line 698 "pikchr.y"
2793	2744	{yylhsminor.yy79 = pik_position_between(yymsp[-4].minor.yy153,yymsp[-2].minor.yy79,yymsp[0].minor.yy79);}
2794		-#line 2819 "pikchr.c"
	2745	+#line 2770 "pikchr.c"
2795	2746	yymsp[-4].minor.yy79 = yylhsminor.yy79;
2796	2747	break;
2797	2748	case 72: /* position ::= expr LT position COMMA position GT */
2798	2749	#line 700 "pikchr.y"
2799	2750	{yylhsminor.yy79 = pik_position_between(yymsp[-5].minor.yy153,yymsp[-3].minor.yy79,yymsp[-1].minor.yy79);}
2800		-#line 2825 "pikchr.c"
	2751	+#line 2776 "pikchr.c"
2801	2752	yymsp[-5].minor.yy79 = yylhsminor.yy79;
2802	2753	break;
2803	2754	case 73: /* position ::= expr ABOVE position */
2804	2755	#line 701 "pikchr.y"
2805	2756	{yylhsminor.yy79=yymsp[0].minor.yy79; yylhsminor.yy79.y += yymsp[-2].minor.yy153;}
2806		-#line 2831 "pikchr.c"
	2757	+#line 2782 "pikchr.c"
2807	2758	yymsp[-2].minor.yy79 = yylhsminor.yy79;
2808	2759	break;
2809	2760	case 74: /* position ::= expr BELOW position */
2810	2761	#line 702 "pikchr.y"
2811	2762	{yylhsminor.yy79=yymsp[0].minor.yy79; yylhsminor.yy79.y -= yymsp[-2].minor.yy153;}
2812		-#line 2837 "pikchr.c"
	2763	+#line 2788 "pikchr.c"
2813	2764	yymsp[-2].minor.yy79 = yylhsminor.yy79;
2814	2765	break;
2815	2766	case 75: /* position ::= expr LEFT OF position */
2816	2767	#line 703 "pikchr.y"
2817	2768	{yylhsminor.yy79=yymsp[0].minor.yy79; yylhsminor.yy79.x -= yymsp[-3].minor.yy153;}
2818		-#line 2843 "pikchr.c"
	2769	+#line 2794 "pikchr.c"
2819	2770	yymsp[-3].minor.yy79 = yylhsminor.yy79;
2820	2771	break;
2821	2772	case 76: /* position ::= expr RIGHT OF position */
2822	2773	#line 704 "pikchr.y"
2823	2774	{yylhsminor.yy79=yymsp[0].minor.yy79; yylhsminor.yy79.x += yymsp[-3].minor.yy153;}
2824		-#line 2849 "pikchr.c"
	2775	+#line 2800 "pikchr.c"
2825	2776	yymsp[-3].minor.yy79 = yylhsminor.yy79;
2826	2777	break;
2827	2778	case 77: /* position ::= expr ON HEADING EDGEPT OF position */
2828	2779	#line 706 "pikchr.y"
2829	2780	{yylhsminor.yy79 = pik_position_at_hdg(yymsp[-5].minor.yy153,&yymsp[-2].minor.yy0,yymsp[0].minor.yy79);}
2830		-#line 2855 "pikchr.c"
	2781	+#line 2806 "pikchr.c"
2831	2782	yymsp[-5].minor.yy79 = yylhsminor.yy79;
2832	2783	break;
2833	2784	case 78: /* position ::= expr HEADING EDGEPT OF position */
2834	2785	#line 708 "pikchr.y"
2835	2786	{yylhsminor.yy79 = pik_position_at_hdg(yymsp[-4].minor.yy153,&yymsp[-2].minor.yy0,yymsp[0].minor.yy79);}
2836		-#line 2861 "pikchr.c"
	2787	+#line 2812 "pikchr.c"
2837	2788	yymsp[-4].minor.yy79 = yylhsminor.yy79;
2838	2789	break;
2839	2790	case 79: /* position ::= expr EDGEPT OF position */
2840	2791	#line 710 "pikchr.y"
2841	2792	{yylhsminor.yy79 = pik_position_at_hdg(yymsp[-3].minor.yy153,&yymsp[-2].minor.yy0,yymsp[0].minor.yy79);}
2842		-#line 2867 "pikchr.c"
	2793	+#line 2818 "pikchr.c"
2843	2794	yymsp[-3].minor.yy79 = yylhsminor.yy79;
2844	2795	break;
2845	2796	case 80: /* position ::= expr ON HEADING expr FROM position */
2846	2797	#line 712 "pikchr.y"
2847	2798	{yylhsminor.yy79 = pik_position_at_angle(yymsp[-5].minor.yy153,yymsp[-2].minor.yy153,yymsp[0].minor.yy79);}
2848		-#line 2873 "pikchr.c"
	2799	+#line 2824 "pikchr.c"
2849	2800	yymsp[-5].minor.yy79 = yylhsminor.yy79;
2850	2801	break;
2851	2802	case 81: /* position ::= expr HEADING expr FROM position */
2852	2803	#line 714 "pikchr.y"
2853	2804	{yylhsminor.yy79 = pik_position_at_angle(yymsp[-4].minor.yy153,yymsp[-2].minor.yy153,yymsp[0].minor.yy79);}
2854		-#line 2879 "pikchr.c"
	2805	+#line 2830 "pikchr.c"
2855	2806	yymsp[-4].minor.yy79 = yylhsminor.yy79;
2856	2807	break;
2857	2808	case 82: /* place ::= edge OF object */
2858	2809	#line 726 "pikchr.y"
2859	2810	{yylhsminor.yy79 = pik_place_of_elem(p,yymsp[0].minor.yy36,&yymsp[-2].minor.yy0);}
2860		-#line 2885 "pikchr.c"
	2811	+#line 2836 "pikchr.c"
2861	2812	yymsp[-2].minor.yy79 = yylhsminor.yy79;
2862	2813	break;
2863	2814	case 83: /* place2 ::= object */
2864	2815	#line 727 "pikchr.y"
2865	2816	{yylhsminor.yy79 = pik_place_of_elem(p,yymsp[0].minor.yy36,0);}
2866		-#line 2891 "pikchr.c"
	2817	+#line 2842 "pikchr.c"
2867	2818	yymsp[0].minor.yy79 = yylhsminor.yy79;
2868	2819	break;
2869	2820	case 84: /* place2 ::= object DOT_E edge */
2870	2821	#line 728 "pikchr.y"
2871	2822	{yylhsminor.yy79 = pik_place_of_elem(p,yymsp[-2].minor.yy36,&yymsp[0].minor.yy0);}
2872		-#line 2897 "pikchr.c"
	2823	+#line 2848 "pikchr.c"
2873	2824	yymsp[-2].minor.yy79 = yylhsminor.yy79;
2874	2825	break;
2875	2826	case 85: /* place2 ::= NTH VERTEX OF object */
2876	2827	#line 729 "pikchr.y"
2877	2828	{yylhsminor.yy79 = pik_nth_vertex(p,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,yymsp[0].minor.yy36);}
2878		-#line 2903 "pikchr.c"
	2829	+#line 2854 "pikchr.c"
2879	2830	yymsp[-3].minor.yy79 = yylhsminor.yy79;
2880	2831	break;
2881	2832	case 86: /* object ::= nth */
2882	2833	#line 741 "pikchr.y"
2883	2834	{yylhsminor.yy36 = pik_find_nth(p,0,&yymsp[0].minor.yy0);}
2884		-#line 2909 "pikchr.c"
	2835	+#line 2860 "pikchr.c"
2885	2836	yymsp[0].minor.yy36 = yylhsminor.yy36;
2886	2837	break;
2887	2838	case 87: /* object ::= nth OF\|IN object */
2888	2839	#line 742 "pikchr.y"
2889	2840	{yylhsminor.yy36 = pik_find_nth(p,yymsp[0].minor.yy36,&yymsp[-2].minor.yy0);}
2890		-#line 2915 "pikchr.c"
	2841	+#line 2866 "pikchr.c"
2891	2842	yymsp[-2].minor.yy36 = yylhsminor.yy36;
2892	2843	break;
2893	2844	case 88: /* objectname ::= THIS */
2894	2845	#line 744 "pikchr.y"
2895	2846	{yymsp[0].minor.yy36 = p->cur;}
2896		-#line 2921 "pikchr.c"
	2847	+#line 2872 "pikchr.c"
2897	2848	break;
2898	2849	case 89: /* objectname ::= PLACENAME */
2899	2850	#line 745 "pikchr.y"
2900	2851	{yylhsminor.yy36 = pik_find_byname(p,0,&yymsp[0].minor.yy0);}
2901		-#line 2926 "pikchr.c"
	2852	+#line 2877 "pikchr.c"
2902	2853	yymsp[0].minor.yy36 = yylhsminor.yy36;
2903	2854	break;
2904	2855	case 90: /* objectname ::= objectname DOT_U PLACENAME */
2905	2856	#line 747 "pikchr.y"
2906	2857	{yylhsminor.yy36 = pik_find_byname(p,yymsp[-2].minor.yy36,&yymsp[0].minor.yy0);}
2907		-#line 2932 "pikchr.c"
	2858	+#line 2883 "pikchr.c"
2908	2859	yymsp[-2].minor.yy36 = yylhsminor.yy36;
2909	2860	break;
2910	2861	case 91: /* nth ::= NTH CLASSNAME */
2911	2862	#line 749 "pikchr.y"
2912	2863	{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = pik_nth_value(p,&yymsp[-1].minor.yy0); }
2913		-#line 2938 "pikchr.c"
	2864	+#line 2889 "pikchr.c"
2914	2865	yymsp[-1].minor.yy0 = yylhsminor.yy0;
2915	2866	break;
2916	2867	case 92: /* nth ::= NTH LAST CLASSNAME */
2917	2868	#line 750 "pikchr.y"
2918	2869	{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = -pik_nth_value(p,&yymsp[-2].minor.yy0); }
2919		-#line 2944 "pikchr.c"
	2870	+#line 2895 "pikchr.c"
2920	2871	yymsp[-2].minor.yy0 = yylhsminor.yy0;
2921	2872	break;
2922	2873	case 93: /* nth ::= LAST CLASSNAME */
2923	2874	#line 751 "pikchr.y"
2924	2875	{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.eCode = -1;}
2925		-#line 2950 "pikchr.c"
	2876	+#line 2901 "pikchr.c"
2926	2877	break;
2927	2878	case 94: /* nth ::= LAST */
2928	2879	#line 752 "pikchr.y"
2929	2880	{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = -1;}
2930		-#line 2955 "pikchr.c"
	2881	+#line 2906 "pikchr.c"
2931	2882	yymsp[0].minor.yy0 = yylhsminor.yy0;
2932	2883	break;
2933	2884	case 95: /* nth ::= NTH LB RB */
2934	2885	#line 753 "pikchr.y"
2935	2886	{yylhsminor.yy0=yymsp[-1].minor.yy0; yylhsminor.yy0.eCode = pik_nth_value(p,&yymsp[-2].minor.yy0);}
2936		-#line 2961 "pikchr.c"
	2887	+#line 2912 "pikchr.c"
2937	2888	yymsp[-2].minor.yy0 = yylhsminor.yy0;
2938	2889	break;
2939	2890	case 96: /* nth ::= NTH LAST LB RB */
2940	2891	#line 754 "pikchr.y"
2941	2892	{yylhsminor.yy0=yymsp[-1].minor.yy0; yylhsminor.yy0.eCode = -pik_nth_value(p,&yymsp[-3].minor.yy0);}
2942		-#line 2967 "pikchr.c"
	2893	+#line 2918 "pikchr.c"
2943	2894	yymsp[-3].minor.yy0 = yylhsminor.yy0;
2944	2895	break;
2945	2896	case 97: /* nth ::= LAST LB RB */
2946	2897	#line 755 "pikchr.y"
2947	2898	{yymsp[-2].minor.yy0=yymsp[-1].minor.yy0; yymsp[-2].minor.yy0.eCode = -1; }
2948		-#line 2973 "pikchr.c"
	2899	+#line 2924 "pikchr.c"
2949	2900	break;
2950	2901	case 98: /* expr ::= expr PLUS expr */
2951	2902	#line 757 "pikchr.y"
2952	2903	{yylhsminor.yy153=yymsp[-2].minor.yy153+yymsp[0].minor.yy153;}
2953		-#line 2978 "pikchr.c"
	2904	+#line 2929 "pikchr.c"
2954	2905	yymsp[-2].minor.yy153 = yylhsminor.yy153;
2955	2906	break;
2956	2907	case 99: /* expr ::= expr MINUS expr */
2957	2908	#line 758 "pikchr.y"
2958	2909	{yylhsminor.yy153=yymsp[-2].minor.yy153-yymsp[0].minor.yy153;}
2959		-#line 2984 "pikchr.c"
	2910	+#line 2935 "pikchr.c"
2960	2911	yymsp[-2].minor.yy153 = yylhsminor.yy153;
2961	2912	break;
2962	2913	case 100: /* expr ::= expr STAR expr */
2963	2914	#line 759 "pikchr.y"
2964	2915	{yylhsminor.yy153=yymsp[-2].minor.yy153*yymsp[0].minor.yy153;}
2965		-#line 2990 "pikchr.c"
	2916	+#line 2941 "pikchr.c"
2966	2917	yymsp[-2].minor.yy153 = yylhsminor.yy153;
2967	2918	break;
2968	2919	case 101: /* expr ::= expr SLASH expr */
2969	2920	#line 760 "pikchr.y"
2970	2921	{
2971	2922	if( yymsp[0].minor.yy153==0.0 ){ pik_error(p, &yymsp[-1].minor.yy0, "division by zero"); yylhsminor.yy153 = 0.0; }
2972	2923	else{ yylhsminor.yy153 = yymsp[-2].minor.yy153/yymsp[0].minor.yy153; }
2973	2924	}
2974		-#line 2999 "pikchr.c"
	2925	+#line 2950 "pikchr.c"
2975	2926	yymsp[-2].minor.yy153 = yylhsminor.yy153;
2976	2927	break;
2977	2928	case 102: /* expr ::= MINUS expr */
2978	2929	#line 764 "pikchr.y"
2979	2930	{yymsp[-1].minor.yy153=-yymsp[0].minor.yy153;}
2980		-#line 3005 "pikchr.c"
	2931	+#line 2956 "pikchr.c"
2981	2932	break;
2982	2933	case 103: /* expr ::= PLUS expr */
2983	2934	#line 765 "pikchr.y"
2984	2935	{yymsp[-1].minor.yy153=yymsp[0].minor.yy153;}
2985		-#line 3010 "pikchr.c"
	2936	+#line 2961 "pikchr.c"
2986	2937	break;
2987	2938	case 104: /* expr ::= LP expr RP */
2988	2939	#line 766 "pikchr.y"
2989	2940	{yymsp[-2].minor.yy153=yymsp[-1].minor.yy153;}
2990		-#line 3015 "pikchr.c"
	2941	+#line 2966 "pikchr.c"
2991	2942	break;
2992	2943	case 105: /* expr ::= LP FILL\|COLOR\|THICKNESS RP */
2993	2944	#line 767 "pikchr.y"
2994	2945	{yymsp[-2].minor.yy153=pik_get_var(p,&yymsp[-1].minor.yy0);}
2995		-#line 3020 "pikchr.c"
	2946	+#line 2971 "pikchr.c"
2996	2947	break;
2997	2948	case 106: /* expr ::= NUMBER */
2998	2949	#line 768 "pikchr.y"
2999	2950	{yylhsminor.yy153=pik_atof(&yymsp[0].minor.yy0);}
3000		-#line 3025 "pikchr.c"
	2951	+#line 2976 "pikchr.c"
3001	2952	yymsp[0].minor.yy153 = yylhsminor.yy153;
3002	2953	break;
3003	2954	case 107: /* expr ::= ID */
3004	2955	#line 769 "pikchr.y"
3005	2956	{yylhsminor.yy153=pik_get_var(p,&yymsp[0].minor.yy0);}
3006		-#line 3031 "pikchr.c"
	2957	+#line 2982 "pikchr.c"
3007	2958	yymsp[0].minor.yy153 = yylhsminor.yy153;
3008	2959	break;
3009	2960	case 108: /* expr ::= FUNC1 LP expr RP */
3010	2961	#line 770 "pikchr.y"
3011	2962	{yylhsminor.yy153 = pik_func(p,&yymsp[-3].minor.yy0,yymsp[-1].minor.yy153,0.0);}
3012		-#line 3037 "pikchr.c"
	2963	+#line 2988 "pikchr.c"
3013	2964	yymsp[-3].minor.yy153 = yylhsminor.yy153;
3014	2965	break;
3015	2966	case 109: /* expr ::= FUNC2 LP expr COMMA expr RP */
3016	2967	#line 771 "pikchr.y"
3017	2968	{yylhsminor.yy153 = pik_func(p,&yymsp[-5].minor.yy0,yymsp[-3].minor.yy153,yymsp[-1].minor.yy153);}
3018		-#line 3043 "pikchr.c"
	2969	+#line 2994 "pikchr.c"
3019	2970	yymsp[-5].minor.yy153 = yylhsminor.yy153;
3020	2971	break;
3021	2972	case 110: /* expr ::= DIST LP position COMMA position RP */
3022	2973	#line 772 "pikchr.y"
3023	2974	{yymsp[-5].minor.yy153 = pik_dist(&yymsp[-3].minor.yy79,&yymsp[-1].minor.yy79);}
3024		-#line 3049 "pikchr.c"
	2975	+#line 3000 "pikchr.c"
3025	2976	break;
3026	2977	case 111: /* expr ::= place2 DOT_XY X */
3027	2978	#line 773 "pikchr.y"
3028	2979	{yylhsminor.yy153 = yymsp[-2].minor.yy79.x;}
3029		-#line 3054 "pikchr.c"
	2980	+#line 3005 "pikchr.c"
3030	2981	yymsp[-2].minor.yy153 = yylhsminor.yy153;
3031	2982	break;
3032	2983	case 112: /* expr ::= place2 DOT_XY Y */
3033	2984	#line 774 "pikchr.y"
3034	2985	{yylhsminor.yy153 = yymsp[-2].minor.yy79.y;}
3035		-#line 3060 "pikchr.c"
	2986	+#line 3011 "pikchr.c"
3036	2987	yymsp[-2].minor.yy153 = yylhsminor.yy153;
3037	2988	break;
3038	2989	case 113: /* expr ::= object DOT_L numproperty */
3039	2990	case 114: /* expr ::= object DOT_L dashproperty */ yytestcase(yyruleno==114);
3040	2991	case 115: /* expr ::= object DOT_L colorproperty */ yytestcase(yyruleno==115);
3041	2992	#line 775 "pikchr.y"
3042	2993	{yylhsminor.yy153=pik_property_of(yymsp[-2].minor.yy36,&yymsp[0].minor.yy0);}
3043		-#line 3068 "pikchr.c"
	2994	+#line 3019 "pikchr.c"
3044	2995	yymsp[-2].minor.yy153 = yylhsminor.yy153;
3045	2996	break;
3046	2997	default:
3047	2998	/* (116) lvalue ::= ID */ yytestcase(yyruleno==116);
3048	2999	/* (117) lvalue ::= FILL */ yytestcase(yyruleno==117);
		@@ -3149,11 +3100,11 @@
3149	3100	pik_error(p, &TOKEN, "syntax error");
3150	3101	}else{
3151	3102	pik_error(p, 0, "syntax error");
3152	3103	}
3153	3104	UNUSED_PARAMETER(yymajor);
3154		-#line 3179 "pikchr.c"
	3105	+#line 3130 "pikchr.c"
3155	3106	/********** End %syntax_error code ****************************************/
3156	3107	pik_parserARG_STORE /* Suppress warning about unused %extra_argument variable */
3157	3108	pik_parserCTX_STORE
3158	3109	}
3159	3110
		@@ -3235,16 +3186,60 @@
3235	3186	yyTracePrompt,yyTokenName[yymajor],yyact-YY_MIN_REDUCE);
3236	3187	}
3237	3188	}
3238	3189	#endif
3239	3190
3240		- do{
	3191	+ while(1){ /* Exit by "break" */
	3192	+ assert( yypParser->yytos>=yypParser->yystack );
3241	3193	assert( yyact==yypParser->yytos->stateno );
3242	3194	yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact);
3243	3195	if( yyact >= YY_MIN_REDUCE ){
3244		- yyact = yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor,
3245		- yyminor pik_parserCTX_PARAM);
	3196	+ unsigned int yyruleno = yyact - YY_MIN_REDUCE; /* Reduce by this rule */
	3197	+#ifndef NDEBUG
	3198	+ assert( yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) );
	3199	+ if( yyTraceFILE ){
	3200	+ int yysize = yyRuleInfoNRhs[yyruleno];
	3201	+ if( yysize ){
	3202	+ fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
	3203	+ yyTracePrompt,
	3204	+ yyruleno, yyRuleName[yyruleno],
	3205	+ yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action",
	3206	+ yypParser->yytos[yysize].stateno);
	3207	+ }else{
	3208	+ fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n",
	3209	+ yyTracePrompt, yyruleno, yyRuleName[yyruleno],
	3210	+ yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action");
	3211	+ }
	3212	+ }
	3213	+#endif /* NDEBUG */
	3214	+
	3215	+ /* Check that the stack is large enough to grow by a single entry
	3216	+ ** if the RHS of the rule is empty. This ensures that there is room
	3217	+ ** enough on the stack to push the LHS value */
	3218	+ if( yyRuleInfoNRhs[yyruleno]==0 ){
	3219	+#ifdef YYTRACKMAXSTACKDEPTH
	3220	+ if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
	3221	+ yypParser->yyhwm++;
	3222	+ assert( yypParser->yyhwm ==
	3223	+ (int)(yypParser->yytos - yypParser->yystack));
	3224	+ }
	3225	+#endif
	3226	+#if YYSTACKDEPTH>0
	3227	+ if( yypParser->yytos>=yypParser->yystackEnd ){
	3228	+ yyStackOverflow(yypParser);
	3229	+ break;
	3230	+ }
	3231	+#else
	3232	+ if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){
	3233	+ if( yyGrowStack(yypParser) ){
	3234	+ yyStackOverflow(yypParser);
	3235	+ break;
	3236	+ }
	3237	+ }
	3238	+#endif
	3239	+ }
	3240	+ yyact = yy_reduce(yypParser,yyruleno,yymajor,yyminor pik_parserCTX_PARAM);
3246	3241	}else if( yyact <= YY_MAX_SHIFTREDUCE ){
3247	3242	yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor);
3248	3243	#ifndef YYNOERRORRECOVERY
3249	3244	yypParser->yyerrcnt--;
3250	3245	#endif
		@@ -3296,18 +3291,17 @@
3296	3291	}
3297	3292	#endif
3298	3293	yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
3299	3294	yymajor = YYNOCODE;
3300	3295	}else{
3301		- while( yypParser->yytos >= yypParser->yystack
3302		- && (yyact = yy_find_reduce_action(
3303		- yypParser->yytos->stateno,
3304		- YYERRORSYMBOL)) > YY_MAX_SHIFTREDUCE
3305		- ){
	3296	+ while( yypParser->yytos > yypParser->yystack ){
	3297	+ yyact = yy_find_reduce_action(yypParser->yytos->stateno,
	3298	+ YYERRORSYMBOL);
	3299	+ if( yyact<=YY_MAX_SHIFTREDUCE ) break;
3306	3300	yy_pop_parser_stack(yypParser);
3307	3301	}
3308		- if( yypParser->yytos < yypParser->yystack \|\| yymajor==0 ){
	3302	+ if( yypParser->yytos <= yypParser->yystack \|\| yymajor==0 ){
3309	3303	yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
3310	3304	yy_parse_failed(yypParser);
3311	3305	#ifndef YYNOERRORRECOVERY
3312	3306	yypParser->yyerrcnt = -1;
3313	3307	#endif
		@@ -3353,11 +3347,11 @@
3353	3347	#endif
3354	3348	}
3355	3349	break;
3356	3350	#endif
3357	3351	}
3358		- }while( yypParser->yytos>yypParser->yystack );
	3352	+ }
3359	3353	#ifndef NDEBUG
3360	3354	if( yyTraceFILE ){
3361	3355	yyStackEntry *i;
3362	3356	char cDiv = '[';
3363	3357	fprintf(yyTraceFILE,"%sReturn. Stack=",yyTracePrompt);
		@@ -8129,6 +8123,6 @@
8129	8123
8130	8124
8131	8125	#endif /* PIKCHR_TCL */
8132	8126
8133	8127
8134		-#line 8159 "pikchr.c"
	8128	+#line 8153 "pikchr.c"
8135	8129

	--- extsrc/pikchr.c
	+++ extsrc/pikchr.c
	@@ -1256,13 +1256,13 @@
1256	yyStackEntry yystackEnd; / Last entry in the stack */
1257	#endif
1258	};
1259	typedef struct yyParser yyParser;
1260
1261	#ifndef NDEBUG
1262	#include <stdio.h>
1263	#include <assert.h>


1264	static FILE *yyTraceFILE = 0;
1265	static char *yyTracePrompt = 0;
1266	#endif /* NDEBUG */
1267
1268	#ifndef NDEBUG
	@@ -2368,59 +2368,10 @@
2368	int yysize; /* Amount to pop the stack */
2369	pik_parserARG_FETCH
2370	(void)yyLookahead;
2371	(void)yyLookaheadToken;
2372	yymsp = yypParser->yytos;
2373	assert( yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) );
2374	#ifndef NDEBUG
2375	if( yyTraceFILE ){
2376	yysize = yyRuleInfoNRhs[yyruleno];
2377	if( yysize ){
2378	fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
2379	yyTracePrompt,
2380	yyruleno, yyRuleName[yyruleno],
2381	yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action",
2382	yymsp[yysize].stateno);
2383	}else{
2384	fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n",
2385	yyTracePrompt, yyruleno, yyRuleName[yyruleno],
2386	yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action");
2387	}
2388	}
2389	#endif /* NDEBUG */
2390
2391	/* Check that the stack is large enough to grow by a single entry
2392	** if the RHS of the rule is empty. This ensures that there is room
2393	** enough on the stack to push the LHS value */
2394	if( yyRuleInfoNRhs[yyruleno]==0 ){
2395	#ifdef YYTRACKMAXSTACKDEPTH
2396	if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
2397	yypParser->yyhwm++;
2398	assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack));
2399	}
2400	#endif
2401	#if YYSTACKDEPTH>0
2402	if( yypParser->yytos>=yypParser->yystackEnd ){
2403	yyStackOverflow(yypParser);
2404	/* The call to yyStackOverflow() above pops the stack until it is
2405	** empty, causing the main parser loop to exit. So the return value
2406	** is never used and does not matter. */
2407	return 0;
2408	}
2409	#else
2410	if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){
2411	if( yyGrowStack(yypParser) ){
2412	yyStackOverflow(yypParser);
2413	/* The call to yyStackOverflow() above pops the stack until it is
2414	** empty, causing the main parser loop to exit. So the return value
2415	** is never used and does not matter. */
2416	return 0;
2417	}
2418	yymsp = yypParser->yytos;
2419	}
2420	#endif
2421	}
2422
2423	switch( yyruleno ){
2424	/* Beginning here are the reduction cases. A typical example
2425	** follows:
2426	** case 0:
	@@ -2432,617 +2383,617 @@
2432	/******** Begin reduce actions ********************************************/
2433	YYMINORTYPE yylhsminor;
2434	case 0: /* document ::= statement_list */
2435	#line 547 "pikchr.y"
2436	{pik_render(p,yymsp[0].minor.yy227);}
2437	#line 2462 "pikchr.c"
2438	break;
2439	case 1: /* statement_list ::= statement */
2440	#line 550 "pikchr.y"
2441	{ yylhsminor.yy227 = pik_elist_append(p,0,yymsp[0].minor.yy36); }
2442	#line 2467 "pikchr.c"
2443	yymsp[0].minor.yy227 = yylhsminor.yy227;
2444	break;
2445	case 2: /* statement_list ::= statement_list EOL statement */
2446	#line 552 "pikchr.y"
2447	{ yylhsminor.yy227 = pik_elist_append(p,yymsp[-2].minor.yy227,yymsp[0].minor.yy36); }
2448	#line 2473 "pikchr.c"
2449	yymsp[-2].minor.yy227 = yylhsminor.yy227;
2450	break;
2451	case 3: /* statement ::= */
2452	#line 555 "pikchr.y"
2453	{ yymsp[1].minor.yy36 = 0; }
2454	#line 2479 "pikchr.c"
2455	break;
2456	case 4: /* statement ::= direction */
2457	#line 556 "pikchr.y"
2458	{ pik_set_direction(p,yymsp[0].minor.yy0.eCode); yylhsminor.yy36=0; }
2459	#line 2484 "pikchr.c"
2460	yymsp[0].minor.yy36 = yylhsminor.yy36;
2461	break;
2462	case 5: /* statement ::= lvalue ASSIGN rvalue */
2463	#line 557 "pikchr.y"
2464	{pik_set_var(p,&yymsp[-2].minor.yy0,yymsp[0].minor.yy153,&yymsp[-1].minor.yy0); yylhsminor.yy36=0;}
2465	#line 2490 "pikchr.c"
2466	yymsp[-2].minor.yy36 = yylhsminor.yy36;
2467	break;
2468	case 6: /* statement ::= PLACENAME COLON unnamed_statement */
2469	#line 559 "pikchr.y"
2470	{ yylhsminor.yy36 = yymsp[0].minor.yy36; pik_elem_setname(p,yymsp[0].minor.yy36,&yymsp[-2].minor.yy0); }
2471	#line 2496 "pikchr.c"
2472	yymsp[-2].minor.yy36 = yylhsminor.yy36;
2473	break;
2474	case 7: /* statement ::= PLACENAME COLON position */
2475	#line 561 "pikchr.y"
2476	{ yylhsminor.yy36 = pik_elem_new(p,0,0,0);
2477	if(yylhsminor.yy36){ yylhsminor.yy36->ptAt = yymsp[0].minor.yy79; pik_elem_setname(p,yylhsminor.yy36,&yymsp[-2].minor.yy0); }}
2478	#line 2503 "pikchr.c"
2479	yymsp[-2].minor.yy36 = yylhsminor.yy36;
2480	break;
2481	case 8: /* statement ::= unnamed_statement */
2482	#line 563 "pikchr.y"
2483	{yylhsminor.yy36 = yymsp[0].minor.yy36;}
2484	#line 2509 "pikchr.c"
2485	yymsp[0].minor.yy36 = yylhsminor.yy36;
2486	break;
2487	case 9: /* statement ::= print prlist */
2488	#line 564 "pikchr.y"
2489	{pik_append(p,"<br>\n",5); yymsp[-1].minor.yy36=0;}
2490	#line 2515 "pikchr.c"
2491	break;
2492	case 10: /* statement ::= ASSERT LP expr EQ expr RP */
2493	#line 569 "pikchr.y"
2494	{yymsp[-5].minor.yy36=pik_assert(p,yymsp[-3].minor.yy153,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy153);}
2495	#line 2520 "pikchr.c"
2496	break;
2497	case 11: /* statement ::= ASSERT LP position EQ position RP */
2498	#line 571 "pikchr.y"
2499	{yymsp[-5].minor.yy36=pik_position_assert(p,&yymsp[-3].minor.yy79,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy79);}
2500	#line 2525 "pikchr.c"
2501	break;
2502	case 12: /* statement ::= DEFINE ID CODEBLOCK */
2503	#line 572 "pikchr.y"
2504	{yymsp[-2].minor.yy36=0; pik_add_macro(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
2505	#line 2530 "pikchr.c"
2506	break;
2507	case 13: /* rvalue ::= PLACENAME */
2508	#line 583 "pikchr.y"
2509	{yylhsminor.yy153 = pik_lookup_color(p,&yymsp[0].minor.yy0);}
2510	#line 2535 "pikchr.c"
2511	yymsp[0].minor.yy153 = yylhsminor.yy153;
2512	break;
2513	case 14: /* pritem ::= FILL */
2514	case 15: /* pritem ::= COLOR */ yytestcase(yyruleno==15);
2515	case 16: /* pritem ::= THICKNESS */ yytestcase(yyruleno==16);
2516	#line 588 "pikchr.y"
2517	{pik_append_num(p,"",pik_value(p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.n,0));}
2518	#line 2543 "pikchr.c"
2519	break;
2520	case 17: /* pritem ::= rvalue */
2521	#line 591 "pikchr.y"
2522	{pik_append_num(p,"",yymsp[0].minor.yy153);}
2523	#line 2548 "pikchr.c"
2524	break;
2525	case 18: /* pritem ::= STRING */
2526	#line 592 "pikchr.y"
2527	{pik_append_text(p,yymsp[0].minor.yy0.z+1,yymsp[0].minor.yy0.n-2,0);}
2528	#line 2553 "pikchr.c"
2529	break;
2530	case 19: /* prsep ::= COMMA */
2531	#line 593 "pikchr.y"
2532	{pik_append(p, " ", 1);}
2533	#line 2558 "pikchr.c"
2534	break;
2535	case 20: /* unnamed_statement ::= basetype attribute_list */
2536	#line 596 "pikchr.y"
2537	{yylhsminor.yy36 = yymsp[-1].minor.yy36; pik_after_adding_attributes(p,yylhsminor.yy36);}
2538	#line 2563 "pikchr.c"
2539	yymsp[-1].minor.yy36 = yylhsminor.yy36;
2540	break;
2541	case 21: /* basetype ::= CLASSNAME */
2542	#line 598 "pikchr.y"
2543	{yylhsminor.yy36 = pik_elem_new(p,&yymsp[0].minor.yy0,0,0); }
2544	#line 2569 "pikchr.c"
2545	yymsp[0].minor.yy36 = yylhsminor.yy36;
2546	break;
2547	case 22: /* basetype ::= STRING textposition */
2548	#line 600 "pikchr.y"
2549	{yymsp[-1].minor.yy0.eCode = yymsp[0].minor.yy164; yylhsminor.yy36 = pik_elem_new(p,0,&yymsp[-1].minor.yy0,0); }
2550	#line 2575 "pikchr.c"
2551	yymsp[-1].minor.yy36 = yylhsminor.yy36;
2552	break;
2553	case 23: /* basetype ::= LB savelist statement_list RB */
2554	#line 602 "pikchr.y"
2555	{ p->list = yymsp[-2].minor.yy227; yymsp[-3].minor.yy36 = pik_elem_new(p,0,0,yymsp[-1].minor.yy227); if(yymsp[-3].minor.yy36) yymsp[-3].minor.yy36->errTok = yymsp[0].minor.yy0; }
2556	#line 2581 "pikchr.c"
2557	break;
2558	case 24: /* savelist ::= */
2559	#line 607 "pikchr.y"
2560	{yymsp[1].minor.yy227 = p->list; p->list = 0;}
2561	#line 2586 "pikchr.c"
2562	break;
2563	case 25: /* relexpr ::= expr */
2564	#line 614 "pikchr.y"
2565	{yylhsminor.yy10.rAbs = yymsp[0].minor.yy153; yylhsminor.yy10.rRel = 0;}
2566	#line 2591 "pikchr.c"
2567	yymsp[0].minor.yy10 = yylhsminor.yy10;
2568	break;
2569	case 26: /* relexpr ::= expr PERCENT */
2570	#line 615 "pikchr.y"
2571	{yylhsminor.yy10.rAbs = 0; yylhsminor.yy10.rRel = yymsp[-1].minor.yy153/100;}
2572	#line 2597 "pikchr.c"
2573	yymsp[-1].minor.yy10 = yylhsminor.yy10;
2574	break;
2575	case 27: /* optrelexpr ::= */
2576	#line 617 "pikchr.y"
2577	{yymsp[1].minor.yy10.rAbs = 0; yymsp[1].minor.yy10.rRel = 1.0;}
2578	#line 2603 "pikchr.c"
2579	break;
2580	case 28: /* attribute_list ::= relexpr alist */
2581	#line 619 "pikchr.y"
2582	{pik_add_direction(p,0,&yymsp[-1].minor.yy10);}
2583	#line 2608 "pikchr.c"
2584	break;
2585	case 29: /* attribute ::= numproperty relexpr */
2586	#line 623 "pikchr.y"
2587	{ pik_set_numprop(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy10); }
2588	#line 2613 "pikchr.c"
2589	break;
2590	case 30: /* attribute ::= dashproperty expr */
2591	#line 624 "pikchr.y"
2592	{ pik_set_dashed(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy153); }
2593	#line 2618 "pikchr.c"
2594	break;
2595	case 31: /* attribute ::= dashproperty */
2596	#line 625 "pikchr.y"
2597	{ pik_set_dashed(p,&yymsp[0].minor.yy0,0); }
2598	#line 2623 "pikchr.c"
2599	break;
2600	case 32: /* attribute ::= colorproperty rvalue */
2601	#line 626 "pikchr.y"
2602	{ pik_set_clrprop(p,&yymsp[-1].minor.yy0,yymsp[0].minor.yy153); }
2603	#line 2628 "pikchr.c"
2604	break;
2605	case 33: /* attribute ::= go direction optrelexpr */
2606	#line 627 "pikchr.y"
2607	{ pik_add_direction(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy10);}
2608	#line 2633 "pikchr.c"
2609	break;
2610	case 34: /* attribute ::= go direction even position */
2611	#line 628 "pikchr.y"
2612	{pik_evenwith(p,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy79);}
2613	#line 2638 "pikchr.c"
2614	break;
2615	case 35: /* attribute ::= CLOSE */
2616	#line 629 "pikchr.y"
2617	{ pik_close_path(p,&yymsp[0].minor.yy0); }
2618	#line 2643 "pikchr.c"
2619	break;
2620	case 36: /* attribute ::= CHOP */
2621	#line 630 "pikchr.y"
2622	{ p->cur->bChop = 1; }
2623	#line 2648 "pikchr.c"
2624	break;
2625	case 37: /* attribute ::= FROM position */
2626	#line 631 "pikchr.y"
2627	{ pik_set_from(p,p->cur,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy79); }
2628	#line 2653 "pikchr.c"
2629	break;
2630	case 38: /* attribute ::= TO position */
2631	#line 632 "pikchr.y"
2632	{ pik_add_to(p,p->cur,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy79); }
2633	#line 2658 "pikchr.c"
2634	break;
2635	case 39: /* attribute ::= THEN */
2636	#line 633 "pikchr.y"
2637	{ pik_then(p, &yymsp[0].minor.yy0, p->cur); }
2638	#line 2663 "pikchr.c"
2639	break;
2640	case 40: /* attribute ::= THEN optrelexpr HEADING expr */
2641	case 42: /* attribute ::= GO optrelexpr HEADING expr */ yytestcase(yyruleno==42);
2642	#line 635 "pikchr.y"
2643	{pik_move_hdg(p,&yymsp[-2].minor.yy10,&yymsp[-1].minor.yy0,yymsp[0].minor.yy153,0,&yymsp[-3].minor.yy0);}
2644	#line 2669 "pikchr.c"
2645	break;
2646	case 41: /* attribute ::= THEN optrelexpr EDGEPT */
2647	case 43: /* attribute ::= GO optrelexpr EDGEPT */ yytestcase(yyruleno==43);
2648	#line 636 "pikchr.y"
2649	{pik_move_hdg(p,&yymsp[-1].minor.yy10,0,0,&yymsp[0].minor.yy0,&yymsp[-2].minor.yy0);}
2650	#line 2675 "pikchr.c"
2651	break;
2652	case 44: /* attribute ::= AT position */
2653	#line 641 "pikchr.y"
2654	{ pik_set_at(p,0,&yymsp[0].minor.yy79,&yymsp[-1].minor.yy0); }
2655	#line 2680 "pikchr.c"
2656	break;
2657	case 45: /* attribute ::= SAME */
2658	#line 643 "pikchr.y"
2659	{pik_same(p,0,&yymsp[0].minor.yy0);}
2660	#line 2685 "pikchr.c"
2661	break;
2662	case 46: /* attribute ::= SAME AS object */
2663	#line 644 "pikchr.y"
2664	{pik_same(p,yymsp[0].minor.yy36,&yymsp[-2].minor.yy0);}
2665	#line 2690 "pikchr.c"
2666	break;
2667	case 47: /* attribute ::= STRING textposition */
2668	#line 645 "pikchr.y"
2669	{pik_add_txt(p,&yymsp[-1].minor.yy0,yymsp[0].minor.yy164);}
2670	#line 2695 "pikchr.c"
2671	break;
2672	case 48: /* attribute ::= FIT */
2673	#line 646 "pikchr.y"
2674	{pik_size_to_fit(p,&yymsp[0].minor.yy0,3); }
2675	#line 2700 "pikchr.c"
2676	break;
2677	case 49: /* attribute ::= BEHIND object */
2678	#line 647 "pikchr.y"
2679	{pik_behind(p,yymsp[0].minor.yy36);}
2680	#line 2705 "pikchr.c"
2681	break;
2682	case 50: /* withclause ::= DOT_E edge AT position */
2683	case 51: /* withclause ::= edge AT position */ yytestcase(yyruleno==51);
2684	#line 655 "pikchr.y"
2685	{ pik_set_at(p,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy79,&yymsp[-1].minor.yy0); }
2686	#line 2711 "pikchr.c"
2687	break;
2688	case 52: /* numproperty ::= HEIGHT\|WIDTH\|RADIUS\|DIAMETER\|THICKNESS */
2689	#line 659 "pikchr.y"
2690	{yylhsminor.yy0 = yymsp[0].minor.yy0;}
2691	#line 2716 "pikchr.c"
2692	yymsp[0].minor.yy0 = yylhsminor.yy0;
2693	break;
2694	case 53: /* boolproperty ::= CW */
2695	#line 670 "pikchr.y"
2696	{p->cur->cw = 1;}
2697	#line 2722 "pikchr.c"
2698	break;
2699	case 54: /* boolproperty ::= CCW */
2700	#line 671 "pikchr.y"
2701	{p->cur->cw = 0;}
2702	#line 2727 "pikchr.c"
2703	break;
2704	case 55: /* boolproperty ::= LARROW */
2705	#line 672 "pikchr.y"
2706	{p->cur->larrow=1; p->cur->rarrow=0; }
2707	#line 2732 "pikchr.c"
2708	break;
2709	case 56: /* boolproperty ::= RARROW */
2710	#line 673 "pikchr.y"
2711	{p->cur->larrow=0; p->cur->rarrow=1; }
2712	#line 2737 "pikchr.c"
2713	break;
2714	case 57: /* boolproperty ::= LRARROW */
2715	#line 674 "pikchr.y"
2716	{p->cur->larrow=1; p->cur->rarrow=1; }
2717	#line 2742 "pikchr.c"
2718	break;
2719	case 58: /* boolproperty ::= INVIS */
2720	#line 675 "pikchr.y"
2721	{p->cur->sw = 0.0;}
2722	#line 2747 "pikchr.c"
2723	break;
2724	case 59: /* boolproperty ::= THICK */
2725	#line 676 "pikchr.y"
2726	{p->cur->sw *= 1.5;}
2727	#line 2752 "pikchr.c"
2728	break;
2729	case 60: /* boolproperty ::= THIN */
2730	#line 677 "pikchr.y"
2731	{p->cur->sw *= 0.67;}
2732	#line 2757 "pikchr.c"
2733	break;
2734	case 61: /* boolproperty ::= SOLID */
2735	#line 678 "pikchr.y"
2736	{p->cur->sw = pik_value(p,"thickness",9,0);
2737	p->cur->dotted = p->cur->dashed = 0.0;}
2738	#line 2763 "pikchr.c"
2739	break;
2740	case 62: /* textposition ::= */
2741	#line 681 "pikchr.y"
2742	{yymsp[1].minor.yy164 = 0;}
2743	#line 2768 "pikchr.c"
2744	break;
2745	case 63: /* textposition ::= textposition CENTER\|LJUST\|RJUST\|ABOVE\|BELOW\|ITALIC\|BOLD\|ALIGNED\|BIG\|SMALL */
2746	#line 684 "pikchr.y"
2747	{yylhsminor.yy164 = (short int)pik_text_position(yymsp[-1].minor.yy164,&yymsp[0].minor.yy0);}
2748	#line 2773 "pikchr.c"
2749	yymsp[-1].minor.yy164 = yylhsminor.yy164;
2750	break;
2751	case 64: /* position ::= expr COMMA expr */
2752	#line 687 "pikchr.y"
2753	{yylhsminor.yy79.x=yymsp[-2].minor.yy153; yylhsminor.yy79.y=yymsp[0].minor.yy153;}
2754	#line 2779 "pikchr.c"
2755	yymsp[-2].minor.yy79 = yylhsminor.yy79;
2756	break;
2757	case 65: /* position ::= place PLUS expr COMMA expr */
2758	#line 689 "pikchr.y"
2759	{yylhsminor.yy79.x=yymsp[-4].minor.yy79.x+yymsp[-2].minor.yy153; yylhsminor.yy79.y=yymsp[-4].minor.yy79.y+yymsp[0].minor.yy153;}
2760	#line 2785 "pikchr.c"
2761	yymsp[-4].minor.yy79 = yylhsminor.yy79;
2762	break;
2763	case 66: /* position ::= place MINUS expr COMMA expr */
2764	#line 690 "pikchr.y"
2765	{yylhsminor.yy79.x=yymsp[-4].minor.yy79.x-yymsp[-2].minor.yy153; yylhsminor.yy79.y=yymsp[-4].minor.yy79.y-yymsp[0].minor.yy153;}
2766	#line 2791 "pikchr.c"
2767	yymsp[-4].minor.yy79 = yylhsminor.yy79;
2768	break;
2769	case 67: /* position ::= place PLUS LP expr COMMA expr RP */
2770	#line 692 "pikchr.y"
2771	{yylhsminor.yy79.x=yymsp[-6].minor.yy79.x+yymsp[-3].minor.yy153; yylhsminor.yy79.y=yymsp[-6].minor.yy79.y+yymsp[-1].minor.yy153;}
2772	#line 2797 "pikchr.c"
2773	yymsp[-6].minor.yy79 = yylhsminor.yy79;
2774	break;
2775	case 68: /* position ::= place MINUS LP expr COMMA expr RP */
2776	#line 694 "pikchr.y"
2777	{yylhsminor.yy79.x=yymsp[-6].minor.yy79.x-yymsp[-3].minor.yy153; yylhsminor.yy79.y=yymsp[-6].minor.yy79.y-yymsp[-1].minor.yy153;}
2778	#line 2803 "pikchr.c"
2779	yymsp[-6].minor.yy79 = yylhsminor.yy79;
2780	break;
2781	case 69: /* position ::= LP position COMMA position RP */
2782	#line 695 "pikchr.y"
2783	{yymsp[-4].minor.yy79.x=yymsp[-3].minor.yy79.x; yymsp[-4].minor.yy79.y=yymsp[-1].minor.yy79.y;}
2784	#line 2809 "pikchr.c"
2785	break;
2786	case 70: /* position ::= LP position RP */
2787	#line 696 "pikchr.y"
2788	{yymsp[-2].minor.yy79=yymsp[-1].minor.yy79;}
2789	#line 2814 "pikchr.c"
2790	break;
2791	case 71: /* position ::= expr between position AND position */
2792	#line 698 "pikchr.y"
2793	{yylhsminor.yy79 = pik_position_between(yymsp[-4].minor.yy153,yymsp[-2].minor.yy79,yymsp[0].minor.yy79);}
2794	#line 2819 "pikchr.c"
2795	yymsp[-4].minor.yy79 = yylhsminor.yy79;
2796	break;
2797	case 72: /* position ::= expr LT position COMMA position GT */
2798	#line 700 "pikchr.y"
2799	{yylhsminor.yy79 = pik_position_between(yymsp[-5].minor.yy153,yymsp[-3].minor.yy79,yymsp[-1].minor.yy79);}
2800	#line 2825 "pikchr.c"
2801	yymsp[-5].minor.yy79 = yylhsminor.yy79;
2802	break;
2803	case 73: /* position ::= expr ABOVE position */
2804	#line 701 "pikchr.y"
2805	{yylhsminor.yy79=yymsp[0].minor.yy79; yylhsminor.yy79.y += yymsp[-2].minor.yy153;}
2806	#line 2831 "pikchr.c"
2807	yymsp[-2].minor.yy79 = yylhsminor.yy79;
2808	break;
2809	case 74: /* position ::= expr BELOW position */
2810	#line 702 "pikchr.y"
2811	{yylhsminor.yy79=yymsp[0].minor.yy79; yylhsminor.yy79.y -= yymsp[-2].minor.yy153;}
2812	#line 2837 "pikchr.c"
2813	yymsp[-2].minor.yy79 = yylhsminor.yy79;
2814	break;
2815	case 75: /* position ::= expr LEFT OF position */
2816	#line 703 "pikchr.y"
2817	{yylhsminor.yy79=yymsp[0].minor.yy79; yylhsminor.yy79.x -= yymsp[-3].minor.yy153;}
2818	#line 2843 "pikchr.c"
2819	yymsp[-3].minor.yy79 = yylhsminor.yy79;
2820	break;
2821	case 76: /* position ::= expr RIGHT OF position */
2822	#line 704 "pikchr.y"
2823	{yylhsminor.yy79=yymsp[0].minor.yy79; yylhsminor.yy79.x += yymsp[-3].minor.yy153;}
2824	#line 2849 "pikchr.c"
2825	yymsp[-3].minor.yy79 = yylhsminor.yy79;
2826	break;
2827	case 77: /* position ::= expr ON HEADING EDGEPT OF position */
2828	#line 706 "pikchr.y"
2829	{yylhsminor.yy79 = pik_position_at_hdg(yymsp[-5].minor.yy153,&yymsp[-2].minor.yy0,yymsp[0].minor.yy79);}
2830	#line 2855 "pikchr.c"
2831	yymsp[-5].minor.yy79 = yylhsminor.yy79;
2832	break;
2833	case 78: /* position ::= expr HEADING EDGEPT OF position */
2834	#line 708 "pikchr.y"
2835	{yylhsminor.yy79 = pik_position_at_hdg(yymsp[-4].minor.yy153,&yymsp[-2].minor.yy0,yymsp[0].minor.yy79);}
2836	#line 2861 "pikchr.c"
2837	yymsp[-4].minor.yy79 = yylhsminor.yy79;
2838	break;
2839	case 79: /* position ::= expr EDGEPT OF position */
2840	#line 710 "pikchr.y"
2841	{yylhsminor.yy79 = pik_position_at_hdg(yymsp[-3].minor.yy153,&yymsp[-2].minor.yy0,yymsp[0].minor.yy79);}
2842	#line 2867 "pikchr.c"
2843	yymsp[-3].minor.yy79 = yylhsminor.yy79;
2844	break;
2845	case 80: /* position ::= expr ON HEADING expr FROM position */
2846	#line 712 "pikchr.y"
2847	{yylhsminor.yy79 = pik_position_at_angle(yymsp[-5].minor.yy153,yymsp[-2].minor.yy153,yymsp[0].minor.yy79);}
2848	#line 2873 "pikchr.c"
2849	yymsp[-5].minor.yy79 = yylhsminor.yy79;
2850	break;
2851	case 81: /* position ::= expr HEADING expr FROM position */
2852	#line 714 "pikchr.y"
2853	{yylhsminor.yy79 = pik_position_at_angle(yymsp[-4].minor.yy153,yymsp[-2].minor.yy153,yymsp[0].minor.yy79);}
2854	#line 2879 "pikchr.c"
2855	yymsp[-4].minor.yy79 = yylhsminor.yy79;
2856	break;
2857	case 82: /* place ::= edge OF object */
2858	#line 726 "pikchr.y"
2859	{yylhsminor.yy79 = pik_place_of_elem(p,yymsp[0].minor.yy36,&yymsp[-2].minor.yy0);}
2860	#line 2885 "pikchr.c"
2861	yymsp[-2].minor.yy79 = yylhsminor.yy79;
2862	break;
2863	case 83: /* place2 ::= object */
2864	#line 727 "pikchr.y"
2865	{yylhsminor.yy79 = pik_place_of_elem(p,yymsp[0].minor.yy36,0);}
2866	#line 2891 "pikchr.c"
2867	yymsp[0].minor.yy79 = yylhsminor.yy79;
2868	break;
2869	case 84: /* place2 ::= object DOT_E edge */
2870	#line 728 "pikchr.y"
2871	{yylhsminor.yy79 = pik_place_of_elem(p,yymsp[-2].minor.yy36,&yymsp[0].minor.yy0);}
2872	#line 2897 "pikchr.c"
2873	yymsp[-2].minor.yy79 = yylhsminor.yy79;
2874	break;
2875	case 85: /* place2 ::= NTH VERTEX OF object */
2876	#line 729 "pikchr.y"
2877	{yylhsminor.yy79 = pik_nth_vertex(p,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,yymsp[0].minor.yy36);}
2878	#line 2903 "pikchr.c"
2879	yymsp[-3].minor.yy79 = yylhsminor.yy79;
2880	break;
2881	case 86: /* object ::= nth */
2882	#line 741 "pikchr.y"
2883	{yylhsminor.yy36 = pik_find_nth(p,0,&yymsp[0].minor.yy0);}
2884	#line 2909 "pikchr.c"
2885	yymsp[0].minor.yy36 = yylhsminor.yy36;
2886	break;
2887	case 87: /* object ::= nth OF\|IN object */
2888	#line 742 "pikchr.y"
2889	{yylhsminor.yy36 = pik_find_nth(p,yymsp[0].minor.yy36,&yymsp[-2].minor.yy0);}
2890	#line 2915 "pikchr.c"
2891	yymsp[-2].minor.yy36 = yylhsminor.yy36;
2892	break;
2893	case 88: /* objectname ::= THIS */
2894	#line 744 "pikchr.y"
2895	{yymsp[0].minor.yy36 = p->cur;}
2896	#line 2921 "pikchr.c"
2897	break;
2898	case 89: /* objectname ::= PLACENAME */
2899	#line 745 "pikchr.y"
2900	{yylhsminor.yy36 = pik_find_byname(p,0,&yymsp[0].minor.yy0);}
2901	#line 2926 "pikchr.c"
2902	yymsp[0].minor.yy36 = yylhsminor.yy36;
2903	break;
2904	case 90: /* objectname ::= objectname DOT_U PLACENAME */
2905	#line 747 "pikchr.y"
2906	{yylhsminor.yy36 = pik_find_byname(p,yymsp[-2].minor.yy36,&yymsp[0].minor.yy0);}
2907	#line 2932 "pikchr.c"
2908	yymsp[-2].minor.yy36 = yylhsminor.yy36;
2909	break;
2910	case 91: /* nth ::= NTH CLASSNAME */
2911	#line 749 "pikchr.y"
2912	{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = pik_nth_value(p,&yymsp[-1].minor.yy0); }
2913	#line 2938 "pikchr.c"
2914	yymsp[-1].minor.yy0 = yylhsminor.yy0;
2915	break;
2916	case 92: /* nth ::= NTH LAST CLASSNAME */
2917	#line 750 "pikchr.y"
2918	{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = -pik_nth_value(p,&yymsp[-2].minor.yy0); }
2919	#line 2944 "pikchr.c"
2920	yymsp[-2].minor.yy0 = yylhsminor.yy0;
2921	break;
2922	case 93: /* nth ::= LAST CLASSNAME */
2923	#line 751 "pikchr.y"
2924	{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.eCode = -1;}
2925	#line 2950 "pikchr.c"
2926	break;
2927	case 94: /* nth ::= LAST */
2928	#line 752 "pikchr.y"
2929	{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = -1;}
2930	#line 2955 "pikchr.c"
2931	yymsp[0].minor.yy0 = yylhsminor.yy0;
2932	break;
2933	case 95: /* nth ::= NTH LB RB */
2934	#line 753 "pikchr.y"
2935	{yylhsminor.yy0=yymsp[-1].minor.yy0; yylhsminor.yy0.eCode = pik_nth_value(p,&yymsp[-2].minor.yy0);}
2936	#line 2961 "pikchr.c"
2937	yymsp[-2].minor.yy0 = yylhsminor.yy0;
2938	break;
2939	case 96: /* nth ::= NTH LAST LB RB */
2940	#line 754 "pikchr.y"
2941	{yylhsminor.yy0=yymsp[-1].minor.yy0; yylhsminor.yy0.eCode = -pik_nth_value(p,&yymsp[-3].minor.yy0);}
2942	#line 2967 "pikchr.c"
2943	yymsp[-3].minor.yy0 = yylhsminor.yy0;
2944	break;
2945	case 97: /* nth ::= LAST LB RB */
2946	#line 755 "pikchr.y"
2947	{yymsp[-2].minor.yy0=yymsp[-1].minor.yy0; yymsp[-2].minor.yy0.eCode = -1; }
2948	#line 2973 "pikchr.c"
2949	break;
2950	case 98: /* expr ::= expr PLUS expr */
2951	#line 757 "pikchr.y"
2952	{yylhsminor.yy153=yymsp[-2].minor.yy153+yymsp[0].minor.yy153;}
2953	#line 2978 "pikchr.c"
2954	yymsp[-2].minor.yy153 = yylhsminor.yy153;
2955	break;
2956	case 99: /* expr ::= expr MINUS expr */
2957	#line 758 "pikchr.y"
2958	{yylhsminor.yy153=yymsp[-2].minor.yy153-yymsp[0].minor.yy153;}
2959	#line 2984 "pikchr.c"
2960	yymsp[-2].minor.yy153 = yylhsminor.yy153;
2961	break;
2962	case 100: /* expr ::= expr STAR expr */
2963	#line 759 "pikchr.y"
2964	{yylhsminor.yy153=yymsp[-2].minor.yy153*yymsp[0].minor.yy153;}
2965	#line 2990 "pikchr.c"
2966	yymsp[-2].minor.yy153 = yylhsminor.yy153;
2967	break;
2968	case 101: /* expr ::= expr SLASH expr */
2969	#line 760 "pikchr.y"
2970	{
2971	if( yymsp[0].minor.yy153==0.0 ){ pik_error(p, &yymsp[-1].minor.yy0, "division by zero"); yylhsminor.yy153 = 0.0; }
2972	else{ yylhsminor.yy153 = yymsp[-2].minor.yy153/yymsp[0].minor.yy153; }
2973	}
2974	#line 2999 "pikchr.c"
2975	yymsp[-2].minor.yy153 = yylhsminor.yy153;
2976	break;
2977	case 102: /* expr ::= MINUS expr */
2978	#line 764 "pikchr.y"
2979	{yymsp[-1].minor.yy153=-yymsp[0].minor.yy153;}
2980	#line 3005 "pikchr.c"
2981	break;
2982	case 103: /* expr ::= PLUS expr */
2983	#line 765 "pikchr.y"
2984	{yymsp[-1].minor.yy153=yymsp[0].minor.yy153;}
2985	#line 3010 "pikchr.c"
2986	break;
2987	case 104: /* expr ::= LP expr RP */
2988	#line 766 "pikchr.y"
2989	{yymsp[-2].minor.yy153=yymsp[-1].minor.yy153;}
2990	#line 3015 "pikchr.c"
2991	break;
2992	case 105: /* expr ::= LP FILL\|COLOR\|THICKNESS RP */
2993	#line 767 "pikchr.y"
2994	{yymsp[-2].minor.yy153=pik_get_var(p,&yymsp[-1].minor.yy0);}
2995	#line 3020 "pikchr.c"
2996	break;
2997	case 106: /* expr ::= NUMBER */
2998	#line 768 "pikchr.y"
2999	{yylhsminor.yy153=pik_atof(&yymsp[0].minor.yy0);}
3000	#line 3025 "pikchr.c"
3001	yymsp[0].minor.yy153 = yylhsminor.yy153;
3002	break;
3003	case 107: /* expr ::= ID */
3004	#line 769 "pikchr.y"
3005	{yylhsminor.yy153=pik_get_var(p,&yymsp[0].minor.yy0);}
3006	#line 3031 "pikchr.c"
3007	yymsp[0].minor.yy153 = yylhsminor.yy153;
3008	break;
3009	case 108: /* expr ::= FUNC1 LP expr RP */
3010	#line 770 "pikchr.y"
3011	{yylhsminor.yy153 = pik_func(p,&yymsp[-3].minor.yy0,yymsp[-1].minor.yy153,0.0);}
3012	#line 3037 "pikchr.c"
3013	yymsp[-3].minor.yy153 = yylhsminor.yy153;
3014	break;
3015	case 109: /* expr ::= FUNC2 LP expr COMMA expr RP */
3016	#line 771 "pikchr.y"
3017	{yylhsminor.yy153 = pik_func(p,&yymsp[-5].minor.yy0,yymsp[-3].minor.yy153,yymsp[-1].minor.yy153);}
3018	#line 3043 "pikchr.c"
3019	yymsp[-5].minor.yy153 = yylhsminor.yy153;
3020	break;
3021	case 110: /* expr ::= DIST LP position COMMA position RP */
3022	#line 772 "pikchr.y"
3023	{yymsp[-5].minor.yy153 = pik_dist(&yymsp[-3].minor.yy79,&yymsp[-1].minor.yy79);}
3024	#line 3049 "pikchr.c"
3025	break;
3026	case 111: /* expr ::= place2 DOT_XY X */
3027	#line 773 "pikchr.y"
3028	{yylhsminor.yy153 = yymsp[-2].minor.yy79.x;}
3029	#line 3054 "pikchr.c"
3030	yymsp[-2].minor.yy153 = yylhsminor.yy153;
3031	break;
3032	case 112: /* expr ::= place2 DOT_XY Y */
3033	#line 774 "pikchr.y"
3034	{yylhsminor.yy153 = yymsp[-2].minor.yy79.y;}
3035	#line 3060 "pikchr.c"
3036	yymsp[-2].minor.yy153 = yylhsminor.yy153;
3037	break;
3038	case 113: /* expr ::= object DOT_L numproperty */
3039	case 114: /* expr ::= object DOT_L dashproperty */ yytestcase(yyruleno==114);
3040	case 115: /* expr ::= object DOT_L colorproperty */ yytestcase(yyruleno==115);
3041	#line 775 "pikchr.y"
3042	{yylhsminor.yy153=pik_property_of(yymsp[-2].minor.yy36,&yymsp[0].minor.yy0);}
3043	#line 3068 "pikchr.c"
3044	yymsp[-2].minor.yy153 = yylhsminor.yy153;
3045	break;
3046	default:
3047	/* (116) lvalue ::= ID */ yytestcase(yyruleno==116);
3048	/* (117) lvalue ::= FILL */ yytestcase(yyruleno==117);
	@@ -3149,11 +3100,11 @@
3149	pik_error(p, &TOKEN, "syntax error");
3150	}else{
3151	pik_error(p, 0, "syntax error");
3152	}
3153	UNUSED_PARAMETER(yymajor);
3154	#line 3179 "pikchr.c"
3155	/********** End %syntax_error code ****************************************/
3156	pik_parserARG_STORE /* Suppress warning about unused %extra_argument variable */
3157	pik_parserCTX_STORE
3158	}
3159
	@@ -3235,16 +3186,60 @@
3235	yyTracePrompt,yyTokenName[yymajor],yyact-YY_MIN_REDUCE);
3236	}
3237	}
3238	#endif
3239
3240	do{

3241	assert( yyact==yypParser->yytos->stateno );
3242	yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact);
3243	if( yyact >= YY_MIN_REDUCE ){
3244	yyact = yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor,
3245	yyminor pik_parserCTX_PARAM);











































3246	}else if( yyact <= YY_MAX_SHIFTREDUCE ){
3247	yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor);
3248	#ifndef YYNOERRORRECOVERY
3249	yypParser->yyerrcnt--;
3250	#endif
	@@ -3296,18 +3291,17 @@
3296	}
3297	#endif
3298	yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
3299	yymajor = YYNOCODE;
3300	}else{
3301	while( yypParser->yytos >= yypParser->yystack
3302	&& (yyact = yy_find_reduce_action(
3303	yypParser->yytos->stateno,
3304	YYERRORSYMBOL)) > YY_MAX_SHIFTREDUCE
3305	){
3306	yy_pop_parser_stack(yypParser);
3307	}
3308	if( yypParser->yytos < yypParser->yystack \|\| yymajor==0 ){
3309	yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
3310	yy_parse_failed(yypParser);
3311	#ifndef YYNOERRORRECOVERY
3312	yypParser->yyerrcnt = -1;
3313	#endif
	@@ -3353,11 +3347,11 @@
3353	#endif
3354	}
3355	break;
3356	#endif
3357	}
3358	}while( yypParser->yytos>yypParser->yystack );
3359	#ifndef NDEBUG
3360	if( yyTraceFILE ){
3361	yyStackEntry *i;
3362	char cDiv = '[';
3363	fprintf(yyTraceFILE,"%sReturn. Stack=",yyTracePrompt);
	@@ -8129,6 +8123,6 @@
8129
8130
8131	#endif /* PIKCHR_TCL */
8132
8133
8134	#line 8159 "pikchr.c"
8135

	--- extsrc/pikchr.c
	+++ extsrc/pikchr.c
	@@ -1256,13 +1256,13 @@
1256	yyStackEntry yystackEnd; / Last entry in the stack */
1257	#endif
1258	};
1259	typedef struct yyParser yyParser;
1260


1261	#include <assert.h>
1262	#ifndef NDEBUG
1263	#include <stdio.h>
1264	static FILE *yyTraceFILE = 0;
1265	static char *yyTracePrompt = 0;
1266	#endif /* NDEBUG */
1267
1268	#ifndef NDEBUG
	@@ -2368,59 +2368,10 @@
2368	int yysize; /* Amount to pop the stack */
2369	pik_parserARG_FETCH
2370	(void)yyLookahead;
2371	(void)yyLookaheadToken;
2372	yymsp = yypParser->yytos;

















































2373
2374	switch( yyruleno ){
2375	/* Beginning here are the reduction cases. A typical example
2376	** follows:
2377	** case 0:
	@@ -2432,617 +2383,617 @@
2383	/******** Begin reduce actions ********************************************/
2384	YYMINORTYPE yylhsminor;
2385	case 0: /* document ::= statement_list */
2386	#line 547 "pikchr.y"
2387	{pik_render(p,yymsp[0].minor.yy227);}
2388	#line 2413 "pikchr.c"
2389	break;
2390	case 1: /* statement_list ::= statement */
2391	#line 550 "pikchr.y"
2392	{ yylhsminor.yy227 = pik_elist_append(p,0,yymsp[0].minor.yy36); }
2393	#line 2418 "pikchr.c"
2394	yymsp[0].minor.yy227 = yylhsminor.yy227;
2395	break;
2396	case 2: /* statement_list ::= statement_list EOL statement */
2397	#line 552 "pikchr.y"
2398	{ yylhsminor.yy227 = pik_elist_append(p,yymsp[-2].minor.yy227,yymsp[0].minor.yy36); }
2399	#line 2424 "pikchr.c"
2400	yymsp[-2].minor.yy227 = yylhsminor.yy227;
2401	break;
2402	case 3: /* statement ::= */
2403	#line 555 "pikchr.y"
2404	{ yymsp[1].minor.yy36 = 0; }
2405	#line 2430 "pikchr.c"
2406	break;
2407	case 4: /* statement ::= direction */
2408	#line 556 "pikchr.y"
2409	{ pik_set_direction(p,yymsp[0].minor.yy0.eCode); yylhsminor.yy36=0; }
2410	#line 2435 "pikchr.c"
2411	yymsp[0].minor.yy36 = yylhsminor.yy36;
2412	break;
2413	case 5: /* statement ::= lvalue ASSIGN rvalue */
2414	#line 557 "pikchr.y"
2415	{pik_set_var(p,&yymsp[-2].minor.yy0,yymsp[0].minor.yy153,&yymsp[-1].minor.yy0); yylhsminor.yy36=0;}
2416	#line 2441 "pikchr.c"
2417	yymsp[-2].minor.yy36 = yylhsminor.yy36;
2418	break;
2419	case 6: /* statement ::= PLACENAME COLON unnamed_statement */
2420	#line 559 "pikchr.y"
2421	{ yylhsminor.yy36 = yymsp[0].minor.yy36; pik_elem_setname(p,yymsp[0].minor.yy36,&yymsp[-2].minor.yy0); }
2422	#line 2447 "pikchr.c"
2423	yymsp[-2].minor.yy36 = yylhsminor.yy36;
2424	break;
2425	case 7: /* statement ::= PLACENAME COLON position */
2426	#line 561 "pikchr.y"
2427	{ yylhsminor.yy36 = pik_elem_new(p,0,0,0);
2428	if(yylhsminor.yy36){ yylhsminor.yy36->ptAt = yymsp[0].minor.yy79; pik_elem_setname(p,yylhsminor.yy36,&yymsp[-2].minor.yy0); }}
2429	#line 2454 "pikchr.c"
2430	yymsp[-2].minor.yy36 = yylhsminor.yy36;
2431	break;
2432	case 8: /* statement ::= unnamed_statement */
2433	#line 563 "pikchr.y"
2434	{yylhsminor.yy36 = yymsp[0].minor.yy36;}
2435	#line 2460 "pikchr.c"
2436	yymsp[0].minor.yy36 = yylhsminor.yy36;
2437	break;
2438	case 9: /* statement ::= print prlist */
2439	#line 564 "pikchr.y"
2440	{pik_append(p,"<br>\n",5); yymsp[-1].minor.yy36=0;}
2441	#line 2466 "pikchr.c"
2442	break;
2443	case 10: /* statement ::= ASSERT LP expr EQ expr RP */
2444	#line 569 "pikchr.y"
2445	{yymsp[-5].minor.yy36=pik_assert(p,yymsp[-3].minor.yy153,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy153);}
2446	#line 2471 "pikchr.c"
2447	break;
2448	case 11: /* statement ::= ASSERT LP position EQ position RP */
2449	#line 571 "pikchr.y"
2450	{yymsp[-5].minor.yy36=pik_position_assert(p,&yymsp[-3].minor.yy79,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy79);}
2451	#line 2476 "pikchr.c"
2452	break;
2453	case 12: /* statement ::= DEFINE ID CODEBLOCK */
2454	#line 572 "pikchr.y"
2455	{yymsp[-2].minor.yy36=0; pik_add_macro(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
2456	#line 2481 "pikchr.c"
2457	break;
2458	case 13: /* rvalue ::= PLACENAME */
2459	#line 583 "pikchr.y"
2460	{yylhsminor.yy153 = pik_lookup_color(p,&yymsp[0].minor.yy0);}
2461	#line 2486 "pikchr.c"
2462	yymsp[0].minor.yy153 = yylhsminor.yy153;
2463	break;
2464	case 14: /* pritem ::= FILL */
2465	case 15: /* pritem ::= COLOR */ yytestcase(yyruleno==15);
2466	case 16: /* pritem ::= THICKNESS */ yytestcase(yyruleno==16);
2467	#line 588 "pikchr.y"
2468	{pik_append_num(p,"",pik_value(p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.n,0));}
2469	#line 2494 "pikchr.c"
2470	break;
2471	case 17: /* pritem ::= rvalue */
2472	#line 591 "pikchr.y"
2473	{pik_append_num(p,"",yymsp[0].minor.yy153);}
2474	#line 2499 "pikchr.c"
2475	break;
2476	case 18: /* pritem ::= STRING */
2477	#line 592 "pikchr.y"
2478	{pik_append_text(p,yymsp[0].minor.yy0.z+1,yymsp[0].minor.yy0.n-2,0);}
2479	#line 2504 "pikchr.c"
2480	break;
2481	case 19: /* prsep ::= COMMA */
2482	#line 593 "pikchr.y"
2483	{pik_append(p, " ", 1);}
2484	#line 2509 "pikchr.c"
2485	break;
2486	case 20: /* unnamed_statement ::= basetype attribute_list */
2487	#line 596 "pikchr.y"
2488	{yylhsminor.yy36 = yymsp[-1].minor.yy36; pik_after_adding_attributes(p,yylhsminor.yy36);}
2489	#line 2514 "pikchr.c"
2490	yymsp[-1].minor.yy36 = yylhsminor.yy36;
2491	break;
2492	case 21: /* basetype ::= CLASSNAME */
2493	#line 598 "pikchr.y"
2494	{yylhsminor.yy36 = pik_elem_new(p,&yymsp[0].minor.yy0,0,0); }
2495	#line 2520 "pikchr.c"
2496	yymsp[0].minor.yy36 = yylhsminor.yy36;
2497	break;
2498	case 22: /* basetype ::= STRING textposition */
2499	#line 600 "pikchr.y"
2500	{yymsp[-1].minor.yy0.eCode = yymsp[0].minor.yy164; yylhsminor.yy36 = pik_elem_new(p,0,&yymsp[-1].minor.yy0,0); }
2501	#line 2526 "pikchr.c"
2502	yymsp[-1].minor.yy36 = yylhsminor.yy36;
2503	break;
2504	case 23: /* basetype ::= LB savelist statement_list RB */
2505	#line 602 "pikchr.y"
2506	{ p->list = yymsp[-2].minor.yy227; yymsp[-3].minor.yy36 = pik_elem_new(p,0,0,yymsp[-1].minor.yy227); if(yymsp[-3].minor.yy36) yymsp[-3].minor.yy36->errTok = yymsp[0].minor.yy0; }
2507	#line 2532 "pikchr.c"
2508	break;
2509	case 24: /* savelist ::= */
2510	#line 607 "pikchr.y"
2511	{yymsp[1].minor.yy227 = p->list; p->list = 0;}
2512	#line 2537 "pikchr.c"
2513	break;
2514	case 25: /* relexpr ::= expr */
2515	#line 614 "pikchr.y"
2516	{yylhsminor.yy10.rAbs = yymsp[0].minor.yy153; yylhsminor.yy10.rRel = 0;}
2517	#line 2542 "pikchr.c"
2518	yymsp[0].minor.yy10 = yylhsminor.yy10;
2519	break;
2520	case 26: /* relexpr ::= expr PERCENT */
2521	#line 615 "pikchr.y"
2522	{yylhsminor.yy10.rAbs = 0; yylhsminor.yy10.rRel = yymsp[-1].minor.yy153/100;}
2523	#line 2548 "pikchr.c"
2524	yymsp[-1].minor.yy10 = yylhsminor.yy10;
2525	break;
2526	case 27: /* optrelexpr ::= */
2527	#line 617 "pikchr.y"
2528	{yymsp[1].minor.yy10.rAbs = 0; yymsp[1].minor.yy10.rRel = 1.0;}
2529	#line 2554 "pikchr.c"
2530	break;
2531	case 28: /* attribute_list ::= relexpr alist */
2532	#line 619 "pikchr.y"
2533	{pik_add_direction(p,0,&yymsp[-1].minor.yy10);}
2534	#line 2559 "pikchr.c"
2535	break;
2536	case 29: /* attribute ::= numproperty relexpr */
2537	#line 623 "pikchr.y"
2538	{ pik_set_numprop(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy10); }
2539	#line 2564 "pikchr.c"
2540	break;
2541	case 30: /* attribute ::= dashproperty expr */
2542	#line 624 "pikchr.y"
2543	{ pik_set_dashed(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy153); }
2544	#line 2569 "pikchr.c"
2545	break;
2546	case 31: /* attribute ::= dashproperty */
2547	#line 625 "pikchr.y"
2548	{ pik_set_dashed(p,&yymsp[0].minor.yy0,0); }
2549	#line 2574 "pikchr.c"
2550	break;
2551	case 32: /* attribute ::= colorproperty rvalue */
2552	#line 626 "pikchr.y"
2553	{ pik_set_clrprop(p,&yymsp[-1].minor.yy0,yymsp[0].minor.yy153); }
2554	#line 2579 "pikchr.c"
2555	break;
2556	case 33: /* attribute ::= go direction optrelexpr */
2557	#line 627 "pikchr.y"
2558	{ pik_add_direction(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy10);}
2559	#line 2584 "pikchr.c"
2560	break;
2561	case 34: /* attribute ::= go direction even position */
2562	#line 628 "pikchr.y"
2563	{pik_evenwith(p,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy79);}
2564	#line 2589 "pikchr.c"
2565	break;
2566	case 35: /* attribute ::= CLOSE */
2567	#line 629 "pikchr.y"
2568	{ pik_close_path(p,&yymsp[0].minor.yy0); }
2569	#line 2594 "pikchr.c"
2570	break;
2571	case 36: /* attribute ::= CHOP */
2572	#line 630 "pikchr.y"
2573	{ p->cur->bChop = 1; }
2574	#line 2599 "pikchr.c"
2575	break;
2576	case 37: /* attribute ::= FROM position */
2577	#line 631 "pikchr.y"
2578	{ pik_set_from(p,p->cur,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy79); }
2579	#line 2604 "pikchr.c"
2580	break;
2581	case 38: /* attribute ::= TO position */
2582	#line 632 "pikchr.y"
2583	{ pik_add_to(p,p->cur,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy79); }
2584	#line 2609 "pikchr.c"
2585	break;
2586	case 39: /* attribute ::= THEN */
2587	#line 633 "pikchr.y"
2588	{ pik_then(p, &yymsp[0].minor.yy0, p->cur); }
2589	#line 2614 "pikchr.c"
2590	break;
2591	case 40: /* attribute ::= THEN optrelexpr HEADING expr */
2592	case 42: /* attribute ::= GO optrelexpr HEADING expr */ yytestcase(yyruleno==42);
2593	#line 635 "pikchr.y"
2594	{pik_move_hdg(p,&yymsp[-2].minor.yy10,&yymsp[-1].minor.yy0,yymsp[0].minor.yy153,0,&yymsp[-3].minor.yy0);}
2595	#line 2620 "pikchr.c"
2596	break;
2597	case 41: /* attribute ::= THEN optrelexpr EDGEPT */
2598	case 43: /* attribute ::= GO optrelexpr EDGEPT */ yytestcase(yyruleno==43);
2599	#line 636 "pikchr.y"
2600	{pik_move_hdg(p,&yymsp[-1].minor.yy10,0,0,&yymsp[0].minor.yy0,&yymsp[-2].minor.yy0);}
2601	#line 2626 "pikchr.c"
2602	break;
2603	case 44: /* attribute ::= AT position */
2604	#line 641 "pikchr.y"
2605	{ pik_set_at(p,0,&yymsp[0].minor.yy79,&yymsp[-1].minor.yy0); }
2606	#line 2631 "pikchr.c"
2607	break;
2608	case 45: /* attribute ::= SAME */
2609	#line 643 "pikchr.y"
2610	{pik_same(p,0,&yymsp[0].minor.yy0);}
2611	#line 2636 "pikchr.c"
2612	break;
2613	case 46: /* attribute ::= SAME AS object */
2614	#line 644 "pikchr.y"
2615	{pik_same(p,yymsp[0].minor.yy36,&yymsp[-2].minor.yy0);}
2616	#line 2641 "pikchr.c"
2617	break;
2618	case 47: /* attribute ::= STRING textposition */
2619	#line 645 "pikchr.y"
2620	{pik_add_txt(p,&yymsp[-1].minor.yy0,yymsp[0].minor.yy164);}
2621	#line 2646 "pikchr.c"
2622	break;
2623	case 48: /* attribute ::= FIT */
2624	#line 646 "pikchr.y"
2625	{pik_size_to_fit(p,&yymsp[0].minor.yy0,3); }
2626	#line 2651 "pikchr.c"
2627	break;
2628	case 49: /* attribute ::= BEHIND object */
2629	#line 647 "pikchr.y"
2630	{pik_behind(p,yymsp[0].minor.yy36);}
2631	#line 2656 "pikchr.c"
2632	break;
2633	case 50: /* withclause ::= DOT_E edge AT position */
2634	case 51: /* withclause ::= edge AT position */ yytestcase(yyruleno==51);
2635	#line 655 "pikchr.y"
2636	{ pik_set_at(p,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy79,&yymsp[-1].minor.yy0); }
2637	#line 2662 "pikchr.c"
2638	break;
2639	case 52: /* numproperty ::= HEIGHT\|WIDTH\|RADIUS\|DIAMETER\|THICKNESS */
2640	#line 659 "pikchr.y"
2641	{yylhsminor.yy0 = yymsp[0].minor.yy0;}
2642	#line 2667 "pikchr.c"
2643	yymsp[0].minor.yy0 = yylhsminor.yy0;
2644	break;
2645	case 53: /* boolproperty ::= CW */
2646	#line 670 "pikchr.y"
2647	{p->cur->cw = 1;}
2648	#line 2673 "pikchr.c"
2649	break;
2650	case 54: /* boolproperty ::= CCW */
2651	#line 671 "pikchr.y"
2652	{p->cur->cw = 0;}
2653	#line 2678 "pikchr.c"
2654	break;
2655	case 55: /* boolproperty ::= LARROW */
2656	#line 672 "pikchr.y"
2657	{p->cur->larrow=1; p->cur->rarrow=0; }
2658	#line 2683 "pikchr.c"
2659	break;
2660	case 56: /* boolproperty ::= RARROW */
2661	#line 673 "pikchr.y"
2662	{p->cur->larrow=0; p->cur->rarrow=1; }
2663	#line 2688 "pikchr.c"
2664	break;
2665	case 57: /* boolproperty ::= LRARROW */
2666	#line 674 "pikchr.y"
2667	{p->cur->larrow=1; p->cur->rarrow=1; }
2668	#line 2693 "pikchr.c"
2669	break;
2670	case 58: /* boolproperty ::= INVIS */
2671	#line 675 "pikchr.y"
2672	{p->cur->sw = 0.0;}
2673	#line 2698 "pikchr.c"
2674	break;
2675	case 59: /* boolproperty ::= THICK */
2676	#line 676 "pikchr.y"
2677	{p->cur->sw *= 1.5;}
2678	#line 2703 "pikchr.c"
2679	break;
2680	case 60: /* boolproperty ::= THIN */
2681	#line 677 "pikchr.y"
2682	{p->cur->sw *= 0.67;}
2683	#line 2708 "pikchr.c"
2684	break;
2685	case 61: /* boolproperty ::= SOLID */
2686	#line 678 "pikchr.y"
2687	{p->cur->sw = pik_value(p,"thickness",9,0);
2688	p->cur->dotted = p->cur->dashed = 0.0;}
2689	#line 2714 "pikchr.c"
2690	break;
2691	case 62: /* textposition ::= */
2692	#line 681 "pikchr.y"
2693	{yymsp[1].minor.yy164 = 0;}
2694	#line 2719 "pikchr.c"
2695	break;
2696	case 63: /* textposition ::= textposition CENTER\|LJUST\|RJUST\|ABOVE\|BELOW\|ITALIC\|BOLD\|ALIGNED\|BIG\|SMALL */
2697	#line 684 "pikchr.y"
2698	{yylhsminor.yy164 = (short int)pik_text_position(yymsp[-1].minor.yy164,&yymsp[0].minor.yy0);}
2699	#line 2724 "pikchr.c"
2700	yymsp[-1].minor.yy164 = yylhsminor.yy164;
2701	break;
2702	case 64: /* position ::= expr COMMA expr */
2703	#line 687 "pikchr.y"
2704	{yylhsminor.yy79.x=yymsp[-2].minor.yy153; yylhsminor.yy79.y=yymsp[0].minor.yy153;}
2705	#line 2730 "pikchr.c"
2706	yymsp[-2].minor.yy79 = yylhsminor.yy79;
2707	break;
2708	case 65: /* position ::= place PLUS expr COMMA expr */
2709	#line 689 "pikchr.y"
2710	{yylhsminor.yy79.x=yymsp[-4].minor.yy79.x+yymsp[-2].minor.yy153; yylhsminor.yy79.y=yymsp[-4].minor.yy79.y+yymsp[0].minor.yy153;}
2711	#line 2736 "pikchr.c"
2712	yymsp[-4].minor.yy79 = yylhsminor.yy79;
2713	break;
2714	case 66: /* position ::= place MINUS expr COMMA expr */
2715	#line 690 "pikchr.y"
2716	{yylhsminor.yy79.x=yymsp[-4].minor.yy79.x-yymsp[-2].minor.yy153; yylhsminor.yy79.y=yymsp[-4].minor.yy79.y-yymsp[0].minor.yy153;}
2717	#line 2742 "pikchr.c"
2718	yymsp[-4].minor.yy79 = yylhsminor.yy79;
2719	break;
2720	case 67: /* position ::= place PLUS LP expr COMMA expr RP */
2721	#line 692 "pikchr.y"
2722	{yylhsminor.yy79.x=yymsp[-6].minor.yy79.x+yymsp[-3].minor.yy153; yylhsminor.yy79.y=yymsp[-6].minor.yy79.y+yymsp[-1].minor.yy153;}
2723	#line 2748 "pikchr.c"
2724	yymsp[-6].minor.yy79 = yylhsminor.yy79;
2725	break;
2726	case 68: /* position ::= place MINUS LP expr COMMA expr RP */
2727	#line 694 "pikchr.y"
2728	{yylhsminor.yy79.x=yymsp[-6].minor.yy79.x-yymsp[-3].minor.yy153; yylhsminor.yy79.y=yymsp[-6].minor.yy79.y-yymsp[-1].minor.yy153;}
2729	#line 2754 "pikchr.c"
2730	yymsp[-6].minor.yy79 = yylhsminor.yy79;
2731	break;
2732	case 69: /* position ::= LP position COMMA position RP */
2733	#line 695 "pikchr.y"
2734	{yymsp[-4].minor.yy79.x=yymsp[-3].minor.yy79.x; yymsp[-4].minor.yy79.y=yymsp[-1].minor.yy79.y;}
2735	#line 2760 "pikchr.c"
2736	break;
2737	case 70: /* position ::= LP position RP */
2738	#line 696 "pikchr.y"
2739	{yymsp[-2].minor.yy79=yymsp[-1].minor.yy79;}
2740	#line 2765 "pikchr.c"
2741	break;
2742	case 71: /* position ::= expr between position AND position */
2743	#line 698 "pikchr.y"
2744	{yylhsminor.yy79 = pik_position_between(yymsp[-4].minor.yy153,yymsp[-2].minor.yy79,yymsp[0].minor.yy79);}
2745	#line 2770 "pikchr.c"
2746	yymsp[-4].minor.yy79 = yylhsminor.yy79;
2747	break;
2748	case 72: /* position ::= expr LT position COMMA position GT */
2749	#line 700 "pikchr.y"
2750	{yylhsminor.yy79 = pik_position_between(yymsp[-5].minor.yy153,yymsp[-3].minor.yy79,yymsp[-1].minor.yy79);}
2751	#line 2776 "pikchr.c"
2752	yymsp[-5].minor.yy79 = yylhsminor.yy79;
2753	break;
2754	case 73: /* position ::= expr ABOVE position */
2755	#line 701 "pikchr.y"
2756	{yylhsminor.yy79=yymsp[0].minor.yy79; yylhsminor.yy79.y += yymsp[-2].minor.yy153;}
2757	#line 2782 "pikchr.c"
2758	yymsp[-2].minor.yy79 = yylhsminor.yy79;
2759	break;
2760	case 74: /* position ::= expr BELOW position */
2761	#line 702 "pikchr.y"
2762	{yylhsminor.yy79=yymsp[0].minor.yy79; yylhsminor.yy79.y -= yymsp[-2].minor.yy153;}
2763	#line 2788 "pikchr.c"
2764	yymsp[-2].minor.yy79 = yylhsminor.yy79;
2765	break;
2766	case 75: /* position ::= expr LEFT OF position */
2767	#line 703 "pikchr.y"
2768	{yylhsminor.yy79=yymsp[0].minor.yy79; yylhsminor.yy79.x -= yymsp[-3].minor.yy153;}
2769	#line 2794 "pikchr.c"
2770	yymsp[-3].minor.yy79 = yylhsminor.yy79;
2771	break;
2772	case 76: /* position ::= expr RIGHT OF position */
2773	#line 704 "pikchr.y"
2774	{yylhsminor.yy79=yymsp[0].minor.yy79; yylhsminor.yy79.x += yymsp[-3].minor.yy153;}
2775	#line 2800 "pikchr.c"
2776	yymsp[-3].minor.yy79 = yylhsminor.yy79;
2777	break;
2778	case 77: /* position ::= expr ON HEADING EDGEPT OF position */
2779	#line 706 "pikchr.y"
2780	{yylhsminor.yy79 = pik_position_at_hdg(yymsp[-5].minor.yy153,&yymsp[-2].minor.yy0,yymsp[0].minor.yy79);}
2781	#line 2806 "pikchr.c"
2782	yymsp[-5].minor.yy79 = yylhsminor.yy79;
2783	break;
2784	case 78: /* position ::= expr HEADING EDGEPT OF position */
2785	#line 708 "pikchr.y"
2786	{yylhsminor.yy79 = pik_position_at_hdg(yymsp[-4].minor.yy153,&yymsp[-2].minor.yy0,yymsp[0].minor.yy79);}
2787	#line 2812 "pikchr.c"
2788	yymsp[-4].minor.yy79 = yylhsminor.yy79;
2789	break;
2790	case 79: /* position ::= expr EDGEPT OF position */
2791	#line 710 "pikchr.y"
2792	{yylhsminor.yy79 = pik_position_at_hdg(yymsp[-3].minor.yy153,&yymsp[-2].minor.yy0,yymsp[0].minor.yy79);}
2793	#line 2818 "pikchr.c"
2794	yymsp[-3].minor.yy79 = yylhsminor.yy79;
2795	break;
2796	case 80: /* position ::= expr ON HEADING expr FROM position */
2797	#line 712 "pikchr.y"
2798	{yylhsminor.yy79 = pik_position_at_angle(yymsp[-5].minor.yy153,yymsp[-2].minor.yy153,yymsp[0].minor.yy79);}
2799	#line 2824 "pikchr.c"
2800	yymsp[-5].minor.yy79 = yylhsminor.yy79;
2801	break;
2802	case 81: /* position ::= expr HEADING expr FROM position */
2803	#line 714 "pikchr.y"
2804	{yylhsminor.yy79 = pik_position_at_angle(yymsp[-4].minor.yy153,yymsp[-2].minor.yy153,yymsp[0].minor.yy79);}
2805	#line 2830 "pikchr.c"
2806	yymsp[-4].minor.yy79 = yylhsminor.yy79;
2807	break;
2808	case 82: /* place ::= edge OF object */
2809	#line 726 "pikchr.y"
2810	{yylhsminor.yy79 = pik_place_of_elem(p,yymsp[0].minor.yy36,&yymsp[-2].minor.yy0);}
2811	#line 2836 "pikchr.c"
2812	yymsp[-2].minor.yy79 = yylhsminor.yy79;
2813	break;
2814	case 83: /* place2 ::= object */
2815	#line 727 "pikchr.y"
2816	{yylhsminor.yy79 = pik_place_of_elem(p,yymsp[0].minor.yy36,0);}
2817	#line 2842 "pikchr.c"
2818	yymsp[0].minor.yy79 = yylhsminor.yy79;
2819	break;
2820	case 84: /* place2 ::= object DOT_E edge */
2821	#line 728 "pikchr.y"
2822	{yylhsminor.yy79 = pik_place_of_elem(p,yymsp[-2].minor.yy36,&yymsp[0].minor.yy0);}
2823	#line 2848 "pikchr.c"
2824	yymsp[-2].minor.yy79 = yylhsminor.yy79;
2825	break;
2826	case 85: /* place2 ::= NTH VERTEX OF object */
2827	#line 729 "pikchr.y"
2828	{yylhsminor.yy79 = pik_nth_vertex(p,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,yymsp[0].minor.yy36);}
2829	#line 2854 "pikchr.c"
2830	yymsp[-3].minor.yy79 = yylhsminor.yy79;
2831	break;
2832	case 86: /* object ::= nth */
2833	#line 741 "pikchr.y"
2834	{yylhsminor.yy36 = pik_find_nth(p,0,&yymsp[0].minor.yy0);}
2835	#line 2860 "pikchr.c"
2836	yymsp[0].minor.yy36 = yylhsminor.yy36;
2837	break;
2838	case 87: /* object ::= nth OF\|IN object */
2839	#line 742 "pikchr.y"
2840	{yylhsminor.yy36 = pik_find_nth(p,yymsp[0].minor.yy36,&yymsp[-2].minor.yy0);}
2841	#line 2866 "pikchr.c"
2842	yymsp[-2].minor.yy36 = yylhsminor.yy36;
2843	break;
2844	case 88: /* objectname ::= THIS */
2845	#line 744 "pikchr.y"
2846	{yymsp[0].minor.yy36 = p->cur;}
2847	#line 2872 "pikchr.c"
2848	break;
2849	case 89: /* objectname ::= PLACENAME */
2850	#line 745 "pikchr.y"
2851	{yylhsminor.yy36 = pik_find_byname(p,0,&yymsp[0].minor.yy0);}
2852	#line 2877 "pikchr.c"
2853	yymsp[0].minor.yy36 = yylhsminor.yy36;
2854	break;
2855	case 90: /* objectname ::= objectname DOT_U PLACENAME */
2856	#line 747 "pikchr.y"
2857	{yylhsminor.yy36 = pik_find_byname(p,yymsp[-2].minor.yy36,&yymsp[0].minor.yy0);}
2858	#line 2883 "pikchr.c"
2859	yymsp[-2].minor.yy36 = yylhsminor.yy36;
2860	break;
2861	case 91: /* nth ::= NTH CLASSNAME */
2862	#line 749 "pikchr.y"
2863	{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = pik_nth_value(p,&yymsp[-1].minor.yy0); }
2864	#line 2889 "pikchr.c"
2865	yymsp[-1].minor.yy0 = yylhsminor.yy0;
2866	break;
2867	case 92: /* nth ::= NTH LAST CLASSNAME */
2868	#line 750 "pikchr.y"
2869	{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = -pik_nth_value(p,&yymsp[-2].minor.yy0); }
2870	#line 2895 "pikchr.c"
2871	yymsp[-2].minor.yy0 = yylhsminor.yy0;
2872	break;
2873	case 93: /* nth ::= LAST CLASSNAME */
2874	#line 751 "pikchr.y"
2875	{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.eCode = -1;}
2876	#line 2901 "pikchr.c"
2877	break;
2878	case 94: /* nth ::= LAST */
2879	#line 752 "pikchr.y"
2880	{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = -1;}
2881	#line 2906 "pikchr.c"
2882	yymsp[0].minor.yy0 = yylhsminor.yy0;
2883	break;
2884	case 95: /* nth ::= NTH LB RB */
2885	#line 753 "pikchr.y"
2886	{yylhsminor.yy0=yymsp[-1].minor.yy0; yylhsminor.yy0.eCode = pik_nth_value(p,&yymsp[-2].minor.yy0);}
2887	#line 2912 "pikchr.c"
2888	yymsp[-2].minor.yy0 = yylhsminor.yy0;
2889	break;
2890	case 96: /* nth ::= NTH LAST LB RB */
2891	#line 754 "pikchr.y"
2892	{yylhsminor.yy0=yymsp[-1].minor.yy0; yylhsminor.yy0.eCode = -pik_nth_value(p,&yymsp[-3].minor.yy0);}
2893	#line 2918 "pikchr.c"
2894	yymsp[-3].minor.yy0 = yylhsminor.yy0;
2895	break;
2896	case 97: /* nth ::= LAST LB RB */
2897	#line 755 "pikchr.y"
2898	{yymsp[-2].minor.yy0=yymsp[-1].minor.yy0; yymsp[-2].minor.yy0.eCode = -1; }
2899	#line 2924 "pikchr.c"
2900	break;
2901	case 98: /* expr ::= expr PLUS expr */
2902	#line 757 "pikchr.y"
2903	{yylhsminor.yy153=yymsp[-2].minor.yy153+yymsp[0].minor.yy153;}
2904	#line 2929 "pikchr.c"
2905	yymsp[-2].minor.yy153 = yylhsminor.yy153;
2906	break;
2907	case 99: /* expr ::= expr MINUS expr */
2908	#line 758 "pikchr.y"
2909	{yylhsminor.yy153=yymsp[-2].minor.yy153-yymsp[0].minor.yy153;}
2910	#line 2935 "pikchr.c"
2911	yymsp[-2].minor.yy153 = yylhsminor.yy153;
2912	break;
2913	case 100: /* expr ::= expr STAR expr */
2914	#line 759 "pikchr.y"
2915	{yylhsminor.yy153=yymsp[-2].minor.yy153*yymsp[0].minor.yy153;}
2916	#line 2941 "pikchr.c"
2917	yymsp[-2].minor.yy153 = yylhsminor.yy153;
2918	break;
2919	case 101: /* expr ::= expr SLASH expr */
2920	#line 760 "pikchr.y"
2921	{
2922	if( yymsp[0].minor.yy153==0.0 ){ pik_error(p, &yymsp[-1].minor.yy0, "division by zero"); yylhsminor.yy153 = 0.0; }
2923	else{ yylhsminor.yy153 = yymsp[-2].minor.yy153/yymsp[0].minor.yy153; }
2924	}
2925	#line 2950 "pikchr.c"
2926	yymsp[-2].minor.yy153 = yylhsminor.yy153;
2927	break;
2928	case 102: /* expr ::= MINUS expr */
2929	#line 764 "pikchr.y"
2930	{yymsp[-1].minor.yy153=-yymsp[0].minor.yy153;}
2931	#line 2956 "pikchr.c"
2932	break;
2933	case 103: /* expr ::= PLUS expr */
2934	#line 765 "pikchr.y"
2935	{yymsp[-1].minor.yy153=yymsp[0].minor.yy153;}
2936	#line 2961 "pikchr.c"
2937	break;
2938	case 104: /* expr ::= LP expr RP */
2939	#line 766 "pikchr.y"
2940	{yymsp[-2].minor.yy153=yymsp[-1].minor.yy153;}
2941	#line 2966 "pikchr.c"
2942	break;
2943	case 105: /* expr ::= LP FILL\|COLOR\|THICKNESS RP */
2944	#line 767 "pikchr.y"
2945	{yymsp[-2].minor.yy153=pik_get_var(p,&yymsp[-1].minor.yy0);}
2946	#line 2971 "pikchr.c"
2947	break;
2948	case 106: /* expr ::= NUMBER */
2949	#line 768 "pikchr.y"
2950	{yylhsminor.yy153=pik_atof(&yymsp[0].minor.yy0);}
2951	#line 2976 "pikchr.c"
2952	yymsp[0].minor.yy153 = yylhsminor.yy153;
2953	break;
2954	case 107: /* expr ::= ID */
2955	#line 769 "pikchr.y"
2956	{yylhsminor.yy153=pik_get_var(p,&yymsp[0].minor.yy0);}
2957	#line 2982 "pikchr.c"
2958	yymsp[0].minor.yy153 = yylhsminor.yy153;
2959	break;
2960	case 108: /* expr ::= FUNC1 LP expr RP */
2961	#line 770 "pikchr.y"
2962	{yylhsminor.yy153 = pik_func(p,&yymsp[-3].minor.yy0,yymsp[-1].minor.yy153,0.0);}
2963	#line 2988 "pikchr.c"
2964	yymsp[-3].minor.yy153 = yylhsminor.yy153;
2965	break;
2966	case 109: /* expr ::= FUNC2 LP expr COMMA expr RP */
2967	#line 771 "pikchr.y"
2968	{yylhsminor.yy153 = pik_func(p,&yymsp[-5].minor.yy0,yymsp[-3].minor.yy153,yymsp[-1].minor.yy153);}
2969	#line 2994 "pikchr.c"
2970	yymsp[-5].minor.yy153 = yylhsminor.yy153;
2971	break;
2972	case 110: /* expr ::= DIST LP position COMMA position RP */
2973	#line 772 "pikchr.y"
2974	{yymsp[-5].minor.yy153 = pik_dist(&yymsp[-3].minor.yy79,&yymsp[-1].minor.yy79);}
2975	#line 3000 "pikchr.c"
2976	break;
2977	case 111: /* expr ::= place2 DOT_XY X */
2978	#line 773 "pikchr.y"
2979	{yylhsminor.yy153 = yymsp[-2].minor.yy79.x;}
2980	#line 3005 "pikchr.c"
2981	yymsp[-2].minor.yy153 = yylhsminor.yy153;
2982	break;
2983	case 112: /* expr ::= place2 DOT_XY Y */
2984	#line 774 "pikchr.y"
2985	{yylhsminor.yy153 = yymsp[-2].minor.yy79.y;}
2986	#line 3011 "pikchr.c"
2987	yymsp[-2].minor.yy153 = yylhsminor.yy153;
2988	break;
2989	case 113: /* expr ::= object DOT_L numproperty */
2990	case 114: /* expr ::= object DOT_L dashproperty */ yytestcase(yyruleno==114);
2991	case 115: /* expr ::= object DOT_L colorproperty */ yytestcase(yyruleno==115);
2992	#line 775 "pikchr.y"
2993	{yylhsminor.yy153=pik_property_of(yymsp[-2].minor.yy36,&yymsp[0].minor.yy0);}
2994	#line 3019 "pikchr.c"
2995	yymsp[-2].minor.yy153 = yylhsminor.yy153;
2996	break;
2997	default:
2998	/* (116) lvalue ::= ID */ yytestcase(yyruleno==116);
2999	/* (117) lvalue ::= FILL */ yytestcase(yyruleno==117);
	@@ -3149,11 +3100,11 @@
3100	pik_error(p, &TOKEN, "syntax error");
3101	}else{
3102	pik_error(p, 0, "syntax error");
3103	}
3104	UNUSED_PARAMETER(yymajor);
3105	#line 3130 "pikchr.c"
3106	/********** End %syntax_error code ****************************************/
3107	pik_parserARG_STORE /* Suppress warning about unused %extra_argument variable */
3108	pik_parserCTX_STORE
3109	}
3110
	@@ -3235,16 +3186,60 @@
3186	yyTracePrompt,yyTokenName[yymajor],yyact-YY_MIN_REDUCE);
3187	}
3188	}
3189	#endif
3190
3191	while(1){ /* Exit by "break" */
3192	assert( yypParser->yytos>=yypParser->yystack );
3193	assert( yyact==yypParser->yytos->stateno );
3194	yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact);
3195	if( yyact >= YY_MIN_REDUCE ){
3196	unsigned int yyruleno = yyact - YY_MIN_REDUCE; /* Reduce by this rule */
3197	#ifndef NDEBUG
3198	assert( yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) );
3199	if( yyTraceFILE ){
3200	int yysize = yyRuleInfoNRhs[yyruleno];
3201	if( yysize ){
3202	fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
3203	yyTracePrompt,
3204	yyruleno, yyRuleName[yyruleno],
3205	yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action",
3206	yypParser->yytos[yysize].stateno);
3207	}else{
3208	fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n",
3209	yyTracePrompt, yyruleno, yyRuleName[yyruleno],
3210	yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action");
3211	}
3212	}
3213	#endif /* NDEBUG */
3214
3215	/* Check that the stack is large enough to grow by a single entry
3216	** if the RHS of the rule is empty. This ensures that there is room
3217	** enough on the stack to push the LHS value */
3218	if( yyRuleInfoNRhs[yyruleno]==0 ){
3219	#ifdef YYTRACKMAXSTACKDEPTH
3220	if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
3221	yypParser->yyhwm++;
3222	assert( yypParser->yyhwm ==
3223	(int)(yypParser->yytos - yypParser->yystack));
3224	}
3225	#endif
3226	#if YYSTACKDEPTH>0
3227	if( yypParser->yytos>=yypParser->yystackEnd ){
3228	yyStackOverflow(yypParser);
3229	break;
3230	}
3231	#else
3232	if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){
3233	if( yyGrowStack(yypParser) ){
3234	yyStackOverflow(yypParser);
3235	break;
3236	}
3237	}
3238	#endif
3239	}
3240	yyact = yy_reduce(yypParser,yyruleno,yymajor,yyminor pik_parserCTX_PARAM);
3241	}else if( yyact <= YY_MAX_SHIFTREDUCE ){
3242	yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor);
3243	#ifndef YYNOERRORRECOVERY
3244	yypParser->yyerrcnt--;
3245	#endif
	@@ -3296,18 +3291,17 @@
3291	}
3292	#endif
3293	yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
3294	yymajor = YYNOCODE;
3295	}else{
3296	while( yypParser->yytos > yypParser->yystack ){
3297	yyact = yy_find_reduce_action(yypParser->yytos->stateno,
3298	YYERRORSYMBOL);
3299	if( yyact<=YY_MAX_SHIFTREDUCE ) break;

3300	yy_pop_parser_stack(yypParser);
3301	}
3302	if( yypParser->yytos <= yypParser->yystack \|\| yymajor==0 ){
3303	yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
3304	yy_parse_failed(yypParser);
3305	#ifndef YYNOERRORRECOVERY
3306	yypParser->yyerrcnt = -1;
3307	#endif
	@@ -3353,11 +3347,11 @@
3347	#endif
3348	}
3349	break;
3350	#endif
3351	}
3352	}
3353	#ifndef NDEBUG
3354	if( yyTraceFILE ){
3355	yyStackEntry *i;
3356	char cDiv = '[';
3357	fprintf(yyTraceFILE,"%sReturn. Stack=",yyTracePrompt);
	@@ -8129,6 +8123,6 @@
8123
8124
8125	#endif /* PIKCHR_TCL */
8126
8127
8128	#line 8153 "pikchr.c"
8129

M extsrc/pikchr.js

+139 -145

		--- extsrc/pikchr.js
		+++ extsrc/pikchr.js
		@@ -116,109 +116,42 @@
116	116
117	117	var ABORT = false;
118	118
119	119	var EXITSTATUS;
120	120
121		-function getCFunc(ident) {
122		- var func = Module["_" + ident];
123		- return func;
124		-}
125		-
126		-function ccall(ident, returnType, argTypes, args, opts) {
127		- var toC = {
128		- "string": function(str) {
129		- var ret = 0;
130		- if (str !== null && str !== undefined && str !== 0) {
131		- var len = (str.length << 2) + 1;
132		- ret = stackAlloc(len);
133		- stringToUTF8(str, ret, len);
134		- }
135		- return ret;
136		- },
137		- "array": function(arr) {
138		- var ret = stackAlloc(arr.length);
139		- writeArrayToMemory(arr, ret);
140		- return ret;
141		- }
142		- };
143		- function convertReturnValue(ret) {
144		- if (returnType === "string") {
145		- return UTF8ToString(ret);
146		- }
147		- if (returnType === "boolean") return Boolean(ret);
148		- return ret;
149		- }
150		- var func = getCFunc(ident);
151		- var cArgs = [];
152		- var stack = 0;
153		- if (args) {
154		- for (var i = 0; i < args.length; i++) {
155		- var converter = toC[argTypes[i]];
156		- if (converter) {
157		- if (stack === 0) stack = stackSave();
158		- cArgs[i] = converter(args[i]);
159		- } else {
160		- cArgs[i] = args[i];
161		- }
162		- }
163		- }
164		- var ret = func.apply(null, cArgs);
165		- function onDone(ret) {
166		- if (stack !== 0) stackRestore(stack);
167		- return convertReturnValue(ret);
168		- }
169		- ret = onDone(ret);
170		- return ret;
171		-}
172		-
173		-function cwrap(ident, returnType, argTypes, opts) {
174		- argTypes = argTypes \|\| [];
175		- var numericArgs = argTypes.every(function(type) {
176		- return type === "number";
177		- });
178		- var numericRet = returnType !== "string";
179		- if (numericRet && numericArgs && !opts) {
180		- return getCFunc(ident);
181		- }
182		- return function() {
183		- return ccall(ident, returnType, argTypes, arguments, opts);
184		- };
185		-}
186		-
187	121	var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
188	122
189	123	function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
190	124	var endIdx = idx + maxBytesToRead;
191	125	var endPtr = idx;
192	126	while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
193	127	if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
194	128	return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
195		- } else {
196		- var str = "";
197		- while (idx < endPtr) {
198		- var u0 = heapOrArray[idx++];
199		- if (!(u0 & 128)) {
200		- str += String.fromCharCode(u0);
201		- continue;
202		- }
203		- var u1 = heapOrArray[idx++] & 63;
204		- if ((u0 & 224) == 192) {
205		- str += String.fromCharCode((u0 & 31) << 6 \| u1);
206		- continue;
207		- }
208		- var u2 = heapOrArray[idx++] & 63;
209		- if ((u0 & 240) == 224) {
210		- u0 = (u0 & 15) << 12 \| u1 << 6 \| u2;
211		- } else {
212		- u0 = (u0 & 7) << 18 \| u1 << 12 \| u2 << 6 \| heapOrArray[idx++] & 63;
213		- }
214		- if (u0 < 65536) {
215		- str += String.fromCharCode(u0);
216		- } else {
217		- var ch = u0 - 65536;
218		- str += String.fromCharCode(55296 \| ch >> 10, 56320 \| ch & 1023);
219		- }
	129	+ }
	130	+ var str = "";
	131	+ while (idx < endPtr) {
	132	+ var u0 = heapOrArray[idx++];
	133	+ if (!(u0 & 128)) {
	134	+ str += String.fromCharCode(u0);
	135	+ continue;
	136	+ }
	137	+ var u1 = heapOrArray[idx++] & 63;
	138	+ if ((u0 & 224) == 192) {
	139	+ str += String.fromCharCode((u0 & 31) << 6 \| u1);
	140	+ continue;
	141	+ }
	142	+ var u2 = heapOrArray[idx++] & 63;
	143	+ if ((u0 & 240) == 224) {
	144	+ u0 = (u0 & 15) << 12 \| u1 << 6 \| u2;
	145	+ } else {
	146	+ u0 = (u0 & 7) << 18 \| u1 << 12 \| u2 << 6 \| heapOrArray[idx++] & 63;
	147	+ }
	148	+ if (u0 < 65536) {
	149	+ str += String.fromCharCode(u0);
	150	+ } else {
	151	+ var ch = u0 - 65536;
	152	+ str += String.fromCharCode(55296 \| ch >> 10, 56320 \| ch & 1023);
220	153	}
221	154	}
222	155	return str;
223	156	}
224	157
		@@ -262,14 +195,10 @@
262	195
263	196	function stringToUTF8(str, outPtr, maxBytesToWrite) {
264	197	return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
265	198	}
266	199
267		-function writeArrayToMemory(array, buffer) {
268		- HEAP8.set(array, buffer);
269		-}
270		-
271	200	var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
272	201
273	202	function updateGlobalBufferAndViews(buf) {
274	203	buffer = buf;
275	204	Module["HEAP8"] = HEAP8 = new Int8Array(buf);
		@@ -401,13 +330,12 @@
401	330	if (file == wasmBinaryFile && wasmBinary) {
402	331	return new Uint8Array(wasmBinary);
403	332	}
404	333	if (readBinary) {
405	334	return readBinary(file);
406		- } else {
407		- throw "both async and sync fetching of the wasm failed";
408	335	}
	336	+ throw "both async and sync fetching of the wasm failed";
409	337	} catch (err) {
410	338	abort(err);
411	339	}
412	340	}
413	341
		@@ -488,33 +416,25 @@
488	416	}
489	417
490	418	var tempDouble;
491	419
492	420	var tempI64;
	421	+
	422	+function ExitStatus(status) {
	423	+ this.name = "ExitStatus";
	424	+ this.message = "Program terminated with exit(" + status + ")";
	425	+ this.status = status;
	426	+}
493	427
494	428	function callRuntimeCallbacks(callbacks) {
495	429	while (callbacks.length > 0) {
496		- var callback = callbacks.shift();
497		- if (typeof callback == "function") {
498		- callback(Module);
499		- continue;
500		- }
501		- var func = callback.func;
502		- if (typeof func == "number") {
503		- if (callback.arg === undefined) {
504		- getWasmTableEntry(func)();
505		- } else {
506		- getWasmTableEntry(func)(callback.arg);
507		- }
508		- } else {
509		- func(callback.arg === undefined ? null : callback.arg);
510		- }
	430	+ callbacks.shift()(Module);
511	431	}
512	432	}
513	433
514	434	function getValue(ptr, type = "i8") {
515		- if (type.endsWith("*")) type = "i32";
	435	+ if (type.endsWith("")) type = "";
516	436	switch (type) {
517	437	case "i1":
518	438	return HEAP8[ptr >> 0];
519	439
520	440	case "i8":
		@@ -531,24 +451,23 @@
531	451
532	452	case "float":
533	453	return HEAPF32[ptr >> 2];
534	454
535	455	case "double":
536		- return Number(HEAPF64[ptr >> 3]);
	456	+ return HEAPF64[ptr >> 3];
	457	+
	458	+ case "*":
	459	+ return HEAPU32[ptr >> 2];
537	460
538	461	default:
539	462	abort("invalid type for getValue: " + type);
540	463	}
541	464	return null;
542	465	}
543	466
544		-function getWasmTableEntry(funcPtr) {
545		- return wasmTable.get(funcPtr);
546		-}
547		-
548	467	function setValue(ptr, value, type = "i8") {
549		- if (type.endsWith("*")) type = "i32";
	468	+ if (type.endsWith("")) type = "";
550	469	switch (type) {
551	470	case "i1":
552	471	HEAP8[ptr >> 0] = value;
553	472	break;
554	473
		@@ -574,15 +493,23 @@
574	493	break;
575	494
576	495	case "double":
577	496	HEAPF64[ptr >> 3] = value;
578	497	break;
	498	+
	499	+ case "*":
	500	+ HEAPU32[ptr >> 2] = value;
	501	+ break;
579	502
580	503	default:
581	504	abort("invalid type for setValue: " + type);
582	505	}
583	506	}
	507	+
	508	+function writeArrayToMemory(array, buffer) {
	509	+ HEAP8.set(array, buffer);
	510	+}
584	511
585	512	function ___assert_fail(condition, filename, line, func) {
586	513	abort("Assertion failed: " + UTF8ToString(condition) + ", at: " + [ filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function" ]);
587	514	}
588	515
		@@ -594,12 +521,101 @@
594	521	var oldSize = HEAPU8.length;
595	522	requestedSize = requestedSize >>> 0;
596	523	abortOnCannotGrowMemory(requestedSize);
597	524	}
598	525
599		-function _exit(status) {
600		- exit(status);
	526	+var SYSCALLS = {
	527	+ varargs: undefined,
	528	+ get: function() {
	529	+ SYSCALLS.varargs += 4;
	530	+ var ret = HEAP32[SYSCALLS.varargs - 4 >> 2];
	531	+ return ret;
	532	+ },
	533	+ getStr: function(ptr) {
	534	+ var ret = UTF8ToString(ptr);
	535	+ return ret;
	536	+ }
	537	+};
	538	+
	539	+function _proc_exit(code) {
	540	+ EXITSTATUS = code;
	541	+ if (!keepRuntimeAlive()) {
	542	+ if (Module["onExit"]) Module["onExit"](code);
	543	+ ABORT = true;
	544	+ }
	545	+ quit_(code, new ExitStatus(code));
	546	+}
	547	+
	548	+function exitJS(status, implicit) {
	549	+ EXITSTATUS = status;
	550	+ _proc_exit(status);
	551	+}
	552	+
	553	+var _exit = exitJS;
	554	+
	555	+function getCFunc(ident) {
	556	+ var func = Module["_" + ident];
	557	+ return func;
	558	+}
	559	+
	560	+function ccall(ident, returnType, argTypes, args, opts) {
	561	+ var toC = {
	562	+ "string": str => {
	563	+ var ret = 0;
	564	+ if (str !== null && str !== undefined && str !== 0) {
	565	+ var len = (str.length << 2) + 1;
	566	+ ret = stackAlloc(len);
	567	+ stringToUTF8(str, ret, len);
	568	+ }
	569	+ return ret;
	570	+ },
	571	+ "array": arr => {
	572	+ var ret = stackAlloc(arr.length);
	573	+ writeArrayToMemory(arr, ret);
	574	+ return ret;
	575	+ }
	576	+ };
	577	+ function convertReturnValue(ret) {
	578	+ if (returnType === "string") {
	579	+ return UTF8ToString(ret);
	580	+ }
	581	+ if (returnType === "boolean") return Boolean(ret);
	582	+ return ret;
	583	+ }
	584	+ var func = getCFunc(ident);
	585	+ var cArgs = [];
	586	+ var stack = 0;
	587	+ if (args) {
	588	+ for (var i = 0; i < args.length; i++) {
	589	+ var converter = toC[argTypes[i]];
	590	+ if (converter) {
	591	+ if (stack === 0) stack = stackSave();
	592	+ cArgs[i] = converter(args[i]);
	593	+ } else {
	594	+ cArgs[i] = args[i];
	595	+ }
	596	+ }
	597	+ }
	598	+ var ret = func.apply(null, cArgs);
	599	+ function onDone(ret) {
	600	+ if (stack !== 0) stackRestore(stack);
	601	+ return convertReturnValue(ret);
	602	+ }
	603	+ ret = onDone(ret);
	604	+ return ret;
	605	+}
	606	+
	607	+function cwrap(ident, returnType, argTypes, opts) {
	608	+ argTypes = argTypes \|\| [];
	609	+ var numericArgs = argTypes.every(type => type === "number" \|\| type === "boolean");
	610	+ var numericRet = returnType !== "string";
	611	+ if (numericRet && numericArgs && !opts) {
	612	+ return getCFunc(ident);
	613	+ }
	614	+ return function() {
	615	+ return ccall(ident, returnType, argTypes, arguments, opts);
	616	+ };
601	617	}
602	618
603	619	var asmLibraryArg = {
604	620	"a": ___assert_fail,
605	621	"b": _emscripten_resize_heap,
		@@ -626,28 +642,22 @@
626	642
627	643	var stackAlloc = Module["stackAlloc"] = function() {
628	644	return (stackAlloc = Module["stackAlloc"] = Module["asm"]["j"]).apply(null, arguments);
629	645	};
630	646
631		-Module["cwrap"] = cwrap;
632		-
633	647	Module["stackSave"] = stackSave;
634	648
635	649	Module["stackRestore"] = stackRestore;
	650	+
	651	+Module["cwrap"] = cwrap;
636	652
637	653	Module["setValue"] = setValue;
638	654
639	655	Module["getValue"] = getValue;
640	656
641	657	var calledRun;
642	658
643		-function ExitStatus(status) {
644		- this.name = "ExitStatus";
645		- this.message = "Program terminated with exit(" + status + ")";
646		- this.status = status;
647		-}
648		-
649	659	dependenciesFulfilled = function runCaller() {
650	660	if (!calledRun) run();
651	661	if (!calledRun) dependenciesFulfilled = runCaller;
652	662	};
653	663
		@@ -681,26 +691,10 @@
681	691	} else {
682	692	doRun();
683	693	}
684	694	}
685	695
686		-Module["run"] = run;
687		-
688		-function exit(status, implicit) {
689		- EXITSTATUS = status;
690		- procExit(status);
691		-}
692		-
693		-function procExit(code) {
694		- EXITSTATUS = code;
695		- if (!keepRuntimeAlive()) {
696		- if (Module["onExit"]) Module["onExit"](code);
697		- ABORT = true;
698		- }
699		- quit_(code, new ExitStatus(code));
700		-}
701		-
702	696	if (Module["preInit"]) {
703	697	if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ];
704	698	while (Module["preInit"].length > 0) {
705	699	Module["preInit"].pop()();
706	700	}
707	701

	--- extsrc/pikchr.js
	+++ extsrc/pikchr.js
	@@ -116,109 +116,42 @@
116
117	var ABORT = false;
118
119	var EXITSTATUS;
120
121	function getCFunc(ident) {
122	var func = Module["_" + ident];
123	return func;
124	}
125
126	function ccall(ident, returnType, argTypes, args, opts) {
127	var toC = {
128	"string": function(str) {
129	var ret = 0;
130	if (str !== null && str !== undefined && str !== 0) {
131	var len = (str.length << 2) + 1;
132	ret = stackAlloc(len);
133	stringToUTF8(str, ret, len);
134	}
135	return ret;
136	},
137	"array": function(arr) {
138	var ret = stackAlloc(arr.length);
139	writeArrayToMemory(arr, ret);
140	return ret;
141	}
142	};
143	function convertReturnValue(ret) {
144	if (returnType === "string") {
145	return UTF8ToString(ret);
146	}
147	if (returnType === "boolean") return Boolean(ret);
148	return ret;
149	}
150	var func = getCFunc(ident);
151	var cArgs = [];
152	var stack = 0;
153	if (args) {
154	for (var i = 0; i < args.length; i++) {
155	var converter = toC[argTypes[i]];
156	if (converter) {
157	if (stack === 0) stack = stackSave();
158	cArgs[i] = converter(args[i]);
159	} else {
160	cArgs[i] = args[i];
161	}
162	}
163	}
164	var ret = func.apply(null, cArgs);
165	function onDone(ret) {
166	if (stack !== 0) stackRestore(stack);
167	return convertReturnValue(ret);
168	}
169	ret = onDone(ret);
170	return ret;
171	}
172
173	function cwrap(ident, returnType, argTypes, opts) {
174	argTypes = argTypes \|\| [];
175	var numericArgs = argTypes.every(function(type) {
176	return type === "number";
177	});
178	var numericRet = returnType !== "string";
179	if (numericRet && numericArgs && !opts) {
180	return getCFunc(ident);
181	}
182	return function() {
183	return ccall(ident, returnType, argTypes, arguments, opts);
184	};
185	}
186
187	var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
188
189	function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
190	var endIdx = idx + maxBytesToRead;
191	var endPtr = idx;
192	while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
193	if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
194	return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
195	} else {
196	var str = "";
197	while (idx < endPtr) {
198	var u0 = heapOrArray[idx++];
199	if (!(u0 & 128)) {
200	str += String.fromCharCode(u0);
201	continue;
202	}
203	var u1 = heapOrArray[idx++] & 63;
204	if ((u0 & 224) == 192) {
205	str += String.fromCharCode((u0 & 31) << 6 \| u1);
206	continue;
207	}
208	var u2 = heapOrArray[idx++] & 63;
209	if ((u0 & 240) == 224) {
210	u0 = (u0 & 15) << 12 \| u1 << 6 \| u2;
211	} else {
212	u0 = (u0 & 7) << 18 \| u1 << 12 \| u2 << 6 \| heapOrArray[idx++] & 63;
213	}
214	if (u0 < 65536) {
215	str += String.fromCharCode(u0);
216	} else {
217	var ch = u0 - 65536;
218	str += String.fromCharCode(55296 \| ch >> 10, 56320 \| ch & 1023);
219	}
220	}
221	}
222	return str;
223	}
224
	@@ -262,14 +195,10 @@
262
263	function stringToUTF8(str, outPtr, maxBytesToWrite) {
264	return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
265	}
266
267	function writeArrayToMemory(array, buffer) {
268	HEAP8.set(array, buffer);
269	}
270
271	var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
272
273	function updateGlobalBufferAndViews(buf) {
274	buffer = buf;
275	Module["HEAP8"] = HEAP8 = new Int8Array(buf);
	@@ -401,13 +330,12 @@
401	if (file == wasmBinaryFile && wasmBinary) {
402	return new Uint8Array(wasmBinary);
403	}
404	if (readBinary) {
405	return readBinary(file);
406	} else {
407	throw "both async and sync fetching of the wasm failed";
408	}

409	} catch (err) {
410	abort(err);
411	}
412	}
413
	@@ -488,33 +416,25 @@
488	}
489
490	var tempDouble;
491
492	var tempI64;






493
494	function callRuntimeCallbacks(callbacks) {
495	while (callbacks.length > 0) {
496	var callback = callbacks.shift();
497	if (typeof callback == "function") {
498	callback(Module);
499	continue;
500	}
501	var func = callback.func;
502	if (typeof func == "number") {
503	if (callback.arg === undefined) {
504	getWasmTableEntry(func)();
505	} else {
506	getWasmTableEntry(func)(callback.arg);
507	}
508	} else {
509	func(callback.arg === undefined ? null : callback.arg);
510	}
511	}
512	}
513
514	function getValue(ptr, type = "i8") {
515	if (type.endsWith("*")) type = "i32";
516	switch (type) {
517	case "i1":
518	return HEAP8[ptr >> 0];
519
520	case "i8":
	@@ -531,24 +451,23 @@
531
532	case "float":
533	return HEAPF32[ptr >> 2];
534
535	case "double":
536	return Number(HEAPF64[ptr >> 3]);



537
538	default:
539	abort("invalid type for getValue: " + type);
540	}
541	return null;
542	}
543
544	function getWasmTableEntry(funcPtr) {
545	return wasmTable.get(funcPtr);
546	}
547
548	function setValue(ptr, value, type = "i8") {
549	if (type.endsWith("*")) type = "i32";
550	switch (type) {
551	case "i1":
552	HEAP8[ptr >> 0] = value;
553	break;
554
	@@ -574,15 +493,23 @@
574	break;
575
576	case "double":
577	HEAPF64[ptr >> 3] = value;
578	break;




579
580	default:
581	abort("invalid type for setValue: " + type);
582	}
583	}




584
585	function ___assert_fail(condition, filename, line, func) {
586	abort("Assertion failed: " + UTF8ToString(condition) + ", at: " + [ filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function" ]);
587	}
588
	@@ -594,12 +521,101 @@
594	var oldSize = HEAPU8.length;
595	requestedSize = requestedSize >>> 0;
596	abortOnCannotGrowMemory(requestedSize);
597	}
598
599	function _exit(status) {
600	exit(status);

























































































601	}
602
603	var asmLibraryArg = {
604	"a": ___assert_fail,
605	"b": _emscripten_resize_heap,
	@@ -626,28 +642,22 @@
626
627	var stackAlloc = Module["stackAlloc"] = function() {
628	return (stackAlloc = Module["stackAlloc"] = Module["asm"]["j"]).apply(null, arguments);
629	};
630
631	Module["cwrap"] = cwrap;
632
633	Module["stackSave"] = stackSave;
634
635	Module["stackRestore"] = stackRestore;


636
637	Module["setValue"] = setValue;
638
639	Module["getValue"] = getValue;
640
641	var calledRun;
642
643	function ExitStatus(status) {
644	this.name = "ExitStatus";
645	this.message = "Program terminated with exit(" + status + ")";
646	this.status = status;
647	}
648
649	dependenciesFulfilled = function runCaller() {
650	if (!calledRun) run();
651	if (!calledRun) dependenciesFulfilled = runCaller;
652	};
653
	@@ -681,26 +691,10 @@
681	} else {
682	doRun();
683	}
684	}
685
686	Module["run"] = run;
687
688	function exit(status, implicit) {
689	EXITSTATUS = status;
690	procExit(status);
691	}
692
693	function procExit(code) {
694	EXITSTATUS = code;
695	if (!keepRuntimeAlive()) {
696	if (Module["onExit"]) Module["onExit"](code);
697	ABORT = true;
698	}
699	quit_(code, new ExitStatus(code));
700	}
701
702	if (Module["preInit"]) {
703	if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ];
704	while (Module["preInit"].length > 0) {
705	Module["preInit"].pop()();
706	}
707

	--- extsrc/pikchr.js
	+++ extsrc/pikchr.js
	@@ -116,109 +116,42 @@
116
117	var ABORT = false;
118
119	var EXITSTATUS;
120


































































121	var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
122
123	function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
124	var endIdx = idx + maxBytesToRead;
125	var endPtr = idx;
126	while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
127	if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
128	return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
129	}
130	var str = "";
131	while (idx < endPtr) {
132	var u0 = heapOrArray[idx++];
133	if (!(u0 & 128)) {
134	str += String.fromCharCode(u0);
135	continue;
136	}
137	var u1 = heapOrArray[idx++] & 63;
138	if ((u0 & 224) == 192) {
139	str += String.fromCharCode((u0 & 31) << 6 \| u1);
140	continue;
141	}
142	var u2 = heapOrArray[idx++] & 63;
143	if ((u0 & 240) == 224) {
144	u0 = (u0 & 15) << 12 \| u1 << 6 \| u2;
145	} else {
146	u0 = (u0 & 7) << 18 \| u1 << 12 \| u2 << 6 \| heapOrArray[idx++] & 63;
147	}
148	if (u0 < 65536) {
149	str += String.fromCharCode(u0);
150	} else {
151	var ch = u0 - 65536;
152	str += String.fromCharCode(55296 \| ch >> 10, 56320 \| ch & 1023);

153	}
154	}
155	return str;
156	}
157
	@@ -262,14 +195,10 @@
195
196	function stringToUTF8(str, outPtr, maxBytesToWrite) {
197	return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
198	}
199




200	var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
201
202	function updateGlobalBufferAndViews(buf) {
203	buffer = buf;
204	Module["HEAP8"] = HEAP8 = new Int8Array(buf);
	@@ -401,13 +330,12 @@
330	if (file == wasmBinaryFile && wasmBinary) {
331	return new Uint8Array(wasmBinary);
332	}
333	if (readBinary) {
334	return readBinary(file);


335	}
336	throw "both async and sync fetching of the wasm failed";
337	} catch (err) {
338	abort(err);
339	}
340	}
341
	@@ -488,33 +416,25 @@
416	}
417
418	var tempDouble;
419
420	var tempI64;
421
422	function ExitStatus(status) {
423	this.name = "ExitStatus";
424	this.message = "Program terminated with exit(" + status + ")";
425	this.status = status;
426	}
427
428	function callRuntimeCallbacks(callbacks) {
429	while (callbacks.length > 0) {
430	callbacks.shift()(Module);














431	}
432	}
433
434	function getValue(ptr, type = "i8") {
435	if (type.endsWith("")) type = "";
436	switch (type) {
437	case "i1":
438	return HEAP8[ptr >> 0];
439
440	case "i8":
	@@ -531,24 +451,23 @@
451
452	case "float":
453	return HEAPF32[ptr >> 2];
454
455	case "double":
456	return HEAPF64[ptr >> 3];
457
458	case "*":
459	return HEAPU32[ptr >> 2];
460
461	default:
462	abort("invalid type for getValue: " + type);
463	}
464	return null;
465	}
466




467	function setValue(ptr, value, type = "i8") {
468	if (type.endsWith("")) type = "";
469	switch (type) {
470	case "i1":
471	HEAP8[ptr >> 0] = value;
472	break;
473
	@@ -574,15 +493,23 @@
493	break;
494
495	case "double":
496	HEAPF64[ptr >> 3] = value;
497	break;
498
499	case "*":
500	HEAPU32[ptr >> 2] = value;
501	break;
502
503	default:
504	abort("invalid type for setValue: " + type);
505	}
506	}
507
508	function writeArrayToMemory(array, buffer) {
509	HEAP8.set(array, buffer);
510	}
511
512	function ___assert_fail(condition, filename, line, func) {
513	abort("Assertion failed: " + UTF8ToString(condition) + ", at: " + [ filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function" ]);
514	}
515
	@@ -594,12 +521,101 @@
521	var oldSize = HEAPU8.length;
522	requestedSize = requestedSize >>> 0;
523	abortOnCannotGrowMemory(requestedSize);
524	}
525
526	var SYSCALLS = {
527	varargs: undefined,
528	get: function() {
529	SYSCALLS.varargs += 4;
530	var ret = HEAP32[SYSCALLS.varargs - 4 >> 2];
531	return ret;
532	},
533	getStr: function(ptr) {
534	var ret = UTF8ToString(ptr);
535	return ret;
536	}
537	};
538
539	function _proc_exit(code) {
540	EXITSTATUS = code;
541	if (!keepRuntimeAlive()) {
542	if (Module["onExit"]) Module["onExit"](code);
543	ABORT = true;
544	}
545	quit_(code, new ExitStatus(code));
546	}
547
548	function exitJS(status, implicit) {
549	EXITSTATUS = status;
550	_proc_exit(status);
551	}
552
553	var _exit = exitJS;
554
555	function getCFunc(ident) {
556	var func = Module["_" + ident];
557	return func;
558	}
559
560	function ccall(ident, returnType, argTypes, args, opts) {
561	var toC = {
562	"string": str => {
563	var ret = 0;
564	if (str !== null && str !== undefined && str !== 0) {
565	var len = (str.length << 2) + 1;
566	ret = stackAlloc(len);
567	stringToUTF8(str, ret, len);
568	}
569	return ret;
570	},
571	"array": arr => {
572	var ret = stackAlloc(arr.length);
573	writeArrayToMemory(arr, ret);
574	return ret;
575	}
576	};
577	function convertReturnValue(ret) {
578	if (returnType === "string") {
579	return UTF8ToString(ret);
580	}
581	if (returnType === "boolean") return Boolean(ret);
582	return ret;
583	}
584	var func = getCFunc(ident);
585	var cArgs = [];
586	var stack = 0;
587	if (args) {
588	for (var i = 0; i < args.length; i++) {
589	var converter = toC[argTypes[i]];
590	if (converter) {
591	if (stack === 0) stack = stackSave();
592	cArgs[i] = converter(args[i]);
593	} else {
594	cArgs[i] = args[i];
595	}
596	}
597	}
598	var ret = func.apply(null, cArgs);
599	function onDone(ret) {
600	if (stack !== 0) stackRestore(stack);
601	return convertReturnValue(ret);
602	}
603	ret = onDone(ret);
604	return ret;
605	}
606
607	function cwrap(ident, returnType, argTypes, opts) {
608	argTypes = argTypes \|\| [];
609	var numericArgs = argTypes.every(type => type === "number" \|\| type === "boolean");
610	var numericRet = returnType !== "string";
611	if (numericRet && numericArgs && !opts) {
612	return getCFunc(ident);
613	}
614	return function() {
615	return ccall(ident, returnType, argTypes, arguments, opts);
616	};
617	}
618
619	var asmLibraryArg = {
620	"a": ___assert_fail,
621	"b": _emscripten_resize_heap,
	@@ -626,28 +642,22 @@
642
643	var stackAlloc = Module["stackAlloc"] = function() {
644	return (stackAlloc = Module["stackAlloc"] = Module["asm"]["j"]).apply(null, arguments);
645	};
646


647	Module["stackSave"] = stackSave;
648
649	Module["stackRestore"] = stackRestore;
650
651	Module["cwrap"] = cwrap;
652
653	Module["setValue"] = setValue;
654
655	Module["getValue"] = getValue;
656
657	var calledRun;
658






659	dependenciesFulfilled = function runCaller() {
660	if (!calledRun) run();
661	if (!calledRun) dependenciesFulfilled = runCaller;
662	};
663
	@@ -681,26 +691,10 @@
691	} else {
692	doRun();
693	}
694	}
695
















696	if (Module["preInit"]) {
697	if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ];
698	while (Module["preInit"].length > 0) {
699	Module["preInit"].pop()();
700	}
701

M extsrc/pikchr.wasm

		--- extsrc/pikchr.wasm
		+++ extsrc/pikchr.wasm
		cannot compute difference between binary files
1	1

	--- extsrc/pikchr.wasm
	+++ extsrc/pikchr.wasm
0	annot compute difference between binary files
1

	--- extsrc/pikchr.wasm
	+++ extsrc/pikchr.wasm
0	annot compute difference between binary files
1

Fossil SCM

Keyboard Shortcuts