Context Navigation

source: src/Tests/Expect-r/ShortCircuit.txt@ ea9b9d3

Visit:

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors ctor deferred_resn demangler enum forall-pointer-decay gc_noraii jacob/cs343-translation jenkins-sandbox memory new-ast new-ast-unique-expr new-env no_list persistent-indexer pthread-emulation qualifiedEnum resolv-new string with_gc

Last change on this file since ea9b9d3 was b1d6dd5, checked in by Peter A. Buhr <pabuhr@…>, 10 years ago
fix parsing error for EOF message, change cfa-ccp -x flag to -v, regression testing third attempt: consolidate example programs
Property mode set to `100644`
File size: 60.5 KB

Line
1	nameExpr is g
2	decl is g: function
3	with parameters
4	float
5	returning
6	nothing
7
8	newExpr is Variable Expression: g: function
9	with parameters
10	float
11	returning
12	nothing
13
14
15	decl is g: function
16	with parameters
17	signed int
18	returning
19	nothing
20
21	newExpr is Variable Expression: g: function
22	with parameters
23	signed int
24	returning
25	nothing
26
27
28	alternatives before prune:
29	Cost ( 0, 0, 0 ): Variable Expression: g: function
30	with parameters
31	float
32	returning
33	nothing
34
35	(types:
36	pointer to function
37	with parameters
38	float
39	returning
40	nothing
41
42	)
43	Environment:
44
45	Cost ( 0, 0, 0 ): Variable Expression: g: function
46	with parameters
47	signed int
48	returning
49	nothing
50
51	(types:
52	pointer to function
53	with parameters
54	signed int
55	returning
56	nothing
57
58	)
59	Environment:
60
61	there are 2 alternatives before elimination
62	there are 2 alternatives after elimination
63	nameExpr is ?!=?
64	decl is ?!=?: function
65	with parameters
66	float
67	float
68	returning
69	signed int
70
71	newExpr is Variable Expression: ?!=?: function
72	with parameters
73	float
74	float
75	returning
76	signed int
77
78
79	decl is ?!=?: function
80	with parameters
81	signed int
82	signed int
83	returning
84	signed int
85
86	newExpr is Variable Expression: ?!=?: function
87	with parameters
88	signed int
89	signed int
90	returning
91	signed int
92
93
94	alternatives before prune:
95	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
96	with parameters
97	float
98	float
99	returning
100	signed int
101
102	(types:
103	pointer to function
104	with parameters
105	float
106	float
107	returning
108	signed int
109
110	)
111	Environment:
112
113	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
114	with parameters
115	signed int
116	signed int
117	returning
118	signed int
119
120	(types:
121	pointer to function
122	with parameters
123	signed int
124	signed int
125	returning
126	signed int
127
128	)
129	Environment:
130
131	there are 2 alternatives before elimination
132	there are 2 alternatives after elimination
133	nameExpr is a
134	decl is a: signed int
135	newExpr is Variable Expression: a: signed int
136
137	alternatives before prune:
138	Cost ( 0, 0, 0 ): Variable Expression: a: signed int
139	(types:
140	lvalue signed int
141	)
142	Environment:
143
144	there are 1 alternatives before elimination
145	there are 1 alternatives after elimination
146	findSubExprs
147	Cost ( 0, 0, 0 ): Variable Expression: a: signed int
148	(types:
149	lvalue signed int
150	)
151	Environment:
152
153	nameExpr is 0
154	decl is 0: signed int
155	newExpr is Variable Expression: 0: signed int
156
157	alternatives before prune:
158	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
159	(types:
160	lvalue signed int
161	)
162	Environment:
163
164	there are 1 alternatives before elimination
165	there are 1 alternatives after elimination
166	findSubExprs
167	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
168	(types:
169	lvalue signed int
170	)
171	Environment:
172
173	working on alternative:
174	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
175	with parameters
176	signed int
177	signed int
178	returning
179	signed int
180
181	(types:
182	pointer to function
183	with parameters
184	signed int
185	signed int
186	returning
187	signed int
188
189	)
190	Environment:
191	formal type is signed int
192	actual type is lvalue signed int
193	formal type is signed int
194	actual type is lvalue signed int
195	need assertions:
196	============= original indexer
197	===idTable===
198	===typeTable===
199	===structTable===
200	===enumTable===
201	===unionTable===
202	===contextTable===
203	============= new indexer
204	===idTable===
205	===typeTable===
206	===structTable===
207	===enumTable===
208	===unionTable===
209	===contextTable===
210	working on alternative:
211	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
212	with parameters
213	float
214	float
215	returning
216	signed int
217
218	(types:
219	pointer to function
220	with parameters
221	float
222	float
223	returning
224	signed int
225
226	)
227	Environment:
228	formal type is float
229	actual type is lvalue signed int
230	formal type is float
231	actual type is lvalue signed int
232	need assertions:
233	============= original indexer
234	===idTable===
235	===typeTable===
236	===structTable===
237	===enumTable===
238	===unionTable===
239	===contextTable===
240	============= new indexer
241	===idTable===
242	===typeTable===
243	===structTable===
244	===enumTable===
245	===unionTable===
246	===contextTable===
247	actual expression:
248	Variable Expression: a: signed int
249	--- results are
250	lvalue signed int
251
252	converting lvalue signed int
253	to signed int
254	cost is( 0, 0, 0 )
255	actual expression:
256	Variable Expression: 0: signed int
257	--- results are
258	lvalue signed int
259
260	converting lvalue signed int
261	to signed int
262	cost is( 0, 0, 0 )
263	Case +++++++++++++
264	formals are:
265	signed int
266	signed int
267	actuals are:
268	Variable Expression: a: signed int
269
270	Variable Expression: 0: signed int
271
272	bindings are:
273	cost of conversion is:( 0, 0, 0 )
274	actual expression:
275	Variable Expression: a: signed int
276	--- results are
277	lvalue signed int
278
279	converting lvalue signed int
280	to float
281	cost is( 0, 0, 5 )
282	actual expression:
283	Variable Expression: 0: signed int
284	--- results are
285	lvalue signed int
286
287	converting lvalue signed int
288	to float
289	cost is( 0, 0, 5 )
290	Case +++++++++++++
291	formals are:
292	float
293	float
294	actuals are:
295	Cast of:
296	Variable Expression: a: signed int
297
298	to:
299	float
300
301	Cast of:
302	Variable Expression: 0: signed int
303
304	to:
305	float
306
307	bindings are:
308	cost of conversion is:( 0, 0, 10 )
309	alternatives before prune:
310	Cost ( 0, 0, 0 ): Application of
311	Variable Expression: ?!=?: function
312	with parameters
313	signed int
314	signed int
315	returning
316	signed int
317
318	to arguments
319	Variable Expression: a: signed int
320
321	Variable Expression: 0: signed int
322
323	(types:
324	signed int
325	)
326	Environment:
327
328	Cost ( 0, 0, 10 ): Application of
329	Variable Expression: ?!=?: function
330	with parameters
331	float
332	float
333	returning
334	signed int
335
336	to arguments
337	Cast of:
338	Variable Expression: a: signed int
339
340	to:
341	float
342
343	Cast of:
344	Variable Expression: 0: signed int
345
346	to:
347	float
348
349	(types:
350	signed int
351	)
352	Environment:
353
354	there are 1 alternatives before elimination
355	there are 1 alternatives after elimination
356	alternatives before prune:
357	Cost ( 0, 0, 0 ): Cast of:
358	Application of
359	Variable Expression: ?!=?: function
360	with parameters
361	signed int
362	signed int
363	returning
364	signed int
365
366	to arguments
367	Variable Expression: a: signed int
368
369	Variable Expression: 0: signed int
370
371
372	to:
373	signed int
374	(types:
375	signed int
376	)
377	Environment:
378
379	there are 1 alternatives before elimination
380	there are 1 alternatives after elimination
381	nameExpr is b
382	decl is b: signed int
383	newExpr is Variable Expression: b: signed int
384
385	alternatives before prune:
386	Cost ( 0, 0, 0 ): Variable Expression: b: signed int
387	(types:
388	lvalue signed int
389	)
390	Environment:
391
392	there are 1 alternatives before elimination
393	there are 1 alternatives after elimination
394	nameExpr is c
395	decl is c: float
396	newExpr is Variable Expression: c: float
397
398	alternatives before prune:
399	Cost ( 0, 0, 0 ): Variable Expression: c: float
400	(types:
401	lvalue float
402	)
403	Environment:
404
405	there are 1 alternatives before elimination
406	there are 1 alternatives after elimination
407	============= original indexer
408	===idTable===
409	===typeTable===
410	===structTable===
411	===enumTable===
412	===unionTable===
413	===contextTable===
414	============= new indexer
415	===idTable===
416	===typeTable===
417	===structTable===
418	===enumTable===
419	===unionTable===
420	===contextTable===
421	alternatives before prune:
422	Cost ( 0, 0, 0 ): Conditional expression on:
423	Cast of:
424	Application of
425	Variable Expression: ?!=?: function
426	with parameters
427	signed int
428	signed int
429	returning
430	signed int
431
432	to arguments
433	Variable Expression: a: signed int
434
435	Variable Expression: 0: signed int
436
437
438	to:
439	signed int
440	First alternative:
441	Variable Expression: b: signed int
442	Second alternative:
443	Variable Expression: c: float
444
445	(types:
446	lvalue float
447	)
448	Environment:
449
450	there are 1 alternatives before elimination
451	there are 1 alternatives after elimination
452	findSubExprs
453	Cost ( 0, 0, 0 ): Conditional expression on:
454	Cast of:
455	Application of
456	Variable Expression: ?!=?: function
457	with parameters
458	signed int
459	signed int
460	returning
461	signed int
462
463	to arguments
464	Variable Expression: a: signed int
465
466	Variable Expression: 0: signed int
467
468
469	to:
470	signed int
471	First alternative:
472	Variable Expression: b: signed int
473	Second alternative:
474	Variable Expression: c: float
475
476	(types:
477	lvalue float
478	)
479	Environment:
480
481	working on alternative:
482	Cost ( 0, 0, 0 ): Variable Expression: g: function
483	with parameters
484	signed int
485	returning
486	nothing
487
488	(types:
489	pointer to function
490	with parameters
491	signed int
492	returning
493	nothing
494
495	)
496	Environment:
497	formal type is signed int
498	actual type is lvalue float
499	need assertions:
500	============= original indexer
501	===idTable===
502	===typeTable===
503	===structTable===
504	===enumTable===
505	===unionTable===
506	===contextTable===
507	============= new indexer
508	===idTable===
509	===typeTable===
510	===structTable===
511	===enumTable===
512	===unionTable===
513	===contextTable===
514	working on alternative:
515	Cost ( 0, 0, 0 ): Variable Expression: g: function
516	with parameters
517	float
518	returning
519	nothing
520
521	(types:
522	pointer to function
523	with parameters
524	float
525	returning
526	nothing
527
528	)
529	Environment:
530	formal type is float
531	actual type is lvalue float
532	need assertions:
533	============= original indexer
534	===idTable===
535	===typeTable===
536	===structTable===
537	===enumTable===
538	===unionTable===
539	===contextTable===
540	============= new indexer
541	===idTable===
542	===typeTable===
543	===structTable===
544	===enumTable===
545	===unionTable===
546	===contextTable===
547	actual expression:
548	Conditional expression on:
549	Cast of:
550	Application of
551	Variable Expression: ?!=?: function
552	with parameters
553	signed int
554	signed int
555	returning
556	signed int
557
558	to arguments
559	Variable Expression: a: signed int
560
561	Variable Expression: 0: signed int
562
563
564	to:
565	signed int
566	First alternative:
567	Variable Expression: b: signed int
568	Second alternative:
569	Variable Expression: c: float
570
571	--- results are
572	lvalue float
573
574	converting lvalue float
575	to signed int
576	cost is( 1, 0, 0 )
577	Case +++++++++++++
578	formals are:
579	signed int
580	actuals are:
581	Cast of:
582	Conditional expression on:
583	Cast of:
584	Application of
585	Variable Expression: ?!=?: function
586	with parameters
587	signed int
588	signed int
589	returning
590	signed int
591
592	to arguments
593	Variable Expression: a: signed int
594
595	Variable Expression: 0: signed int
596
597
598	to:
599	signed int
600	First alternative:
601	Variable Expression: b: signed int
602	Second alternative:
603	Variable Expression: c: float
604
605
606	to:
607	signed int
608
609	bindings are:
610	cost of conversion is:( 1, 0, 0 )
611	actual expression:
612	Conditional expression on:
613	Cast of:
614	Application of
615	Variable Expression: ?!=?: function
616	with parameters
617	signed int
618	signed int
619	returning
620	signed int
621
622	to arguments
623	Variable Expression: a: signed int
624
625	Variable Expression: 0: signed int
626
627
628	to:
629	signed int
630	First alternative:
631	Variable Expression: b: signed int
632	Second alternative:
633	Variable Expression: c: float
634
635	--- results are
636	lvalue float
637
638	converting lvalue float
639	to float
640	cost is( 0, 0, 0 )
641	Case +++++++++++++
642	formals are:
643	float
644	actuals are:
645	Conditional expression on:
646	Cast of:
647	Application of
648	Variable Expression: ?!=?: function
649	with parameters
650	signed int
651	signed int
652	returning
653	signed int
654
655	to arguments
656	Variable Expression: a: signed int
657
658	Variable Expression: 0: signed int
659
660
661	to:
662	signed int
663	First alternative:
664	Variable Expression: b: signed int
665	Second alternative:
666	Variable Expression: c: float
667
668
669	bindings are:
670	cost of conversion is:( 0, 0, 0 )
671	alternatives before prune:
672	Cost ( 1, 0, 0 ): Application of
673	Variable Expression: g: function
674	with parameters
675	signed int
676	returning
677	nothing
678
679	to arguments
680	Cast of:
681	Conditional expression on:
682	Cast of:
683	Application of
684	Variable Expression: ?!=?: function
685	with parameters
686	signed int
687	signed int
688	returning
689	signed int
690
691	to arguments
692	Variable Expression: a: signed int
693
694	Variable Expression: 0: signed int
695
696
697	to:
698	signed int
699	First alternative:
700	Variable Expression: b: signed int
701	Second alternative:
702	Variable Expression: c: float
703
704
705	to:
706	signed int
707
708	(types:
709	)
710	Environment:
711
712	Cost ( 0, 0, 0 ): Application of
713	Variable Expression: g: function
714	with parameters
715	float
716	returning
717	nothing
718
719	to arguments
720	Conditional expression on:
721	Cast of:
722	Application of
723	Variable Expression: ?!=?: function
724	with parameters
725	signed int
726	signed int
727	returning
728	signed int
729
730	to arguments
731	Variable Expression: a: signed int
732
733	Variable Expression: 0: signed int
734
735
736	to:
737	signed int
738	First alternative:
739	Variable Expression: b: signed int
740	Second alternative:
741	Variable Expression: c: float
742
743
744	(types:
745	)
746	Environment:
747
748	cost ( 0, 0, 0 ) beats ( 1, 0, 0 )
749	there are 1 alternatives before elimination
750	there are 1 alternatives after elimination
751	alternatives before prune:
752	Cost ( 0, 0, 0 ): Cast of:
753	Application of
754	Variable Expression: g: function
755	with parameters
756	float
757	returning
758	nothing
759
760	to arguments
761	Conditional expression on:
762	Cast of:
763	Application of
764	Variable Expression: ?!=?: function
765	with parameters
766	signed int
767	signed int
768	returning
769	signed int
770
771	to arguments
772	Variable Expression: a: signed int
773
774	Variable Expression: 0: signed int
775
776
777	to:
778	signed int
779	First alternative:
780	Variable Expression: b: signed int
781	Second alternative:
782	Variable Expression: c: float
783
784
785
786	to:
787	nothing
788	(types:
789	)
790	Environment:
791
792	there are 1 alternatives before elimination
793	there are 1 alternatives after elimination
794	nameExpr is g
795	decl is g: function
796	with parameters
797	float
798	returning
799	nothing
800
801	newExpr is Variable Expression: g: function
802	with parameters
803	float
804	returning
805	nothing
806
807
808	decl is g: function
809	with parameters
810	signed int
811	returning
812	nothing
813
814	newExpr is Variable Expression: g: function
815	with parameters
816	signed int
817	returning
818	nothing
819
820
821	alternatives before prune:
822	Cost ( 0, 0, 0 ): Variable Expression: g: function
823	with parameters
824	float
825	returning
826	nothing
827
828	(types:
829	pointer to function
830	with parameters
831	float
832	returning
833	nothing
834
835	)
836	Environment:
837
838	Cost ( 0, 0, 0 ): Variable Expression: g: function
839	with parameters
840	signed int
841	returning
842	nothing
843
844	(types:
845	pointer to function
846	with parameters
847	signed int
848	returning
849	nothing
850
851	)
852	Environment:
853
854	there are 2 alternatives before elimination
855	there are 2 alternatives after elimination
856	nameExpr is ?!=?
857	decl is ?!=?: function
858	with parameters
859	float
860	float
861	returning
862	signed int
863
864	newExpr is Variable Expression: ?!=?: function
865	with parameters
866	float
867	float
868	returning
869	signed int
870
871
872	decl is ?!=?: function
873	with parameters
874	signed int
875	signed int
876	returning
877	signed int
878
879	newExpr is Variable Expression: ?!=?: function
880	with parameters
881	signed int
882	signed int
883	returning
884	signed int
885
886
887	alternatives before prune:
888	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
889	with parameters
890	float
891	float
892	returning
893	signed int
894
895	(types:
896	pointer to function
897	with parameters
898	float
899	float
900	returning
901	signed int
902
903	)
904	Environment:
905
906	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
907	with parameters
908	signed int
909	signed int
910	returning
911	signed int
912
913	(types:
914	pointer to function
915	with parameters
916	signed int
917	signed int
918	returning
919	signed int
920
921	)
922	Environment:
923
924	there are 2 alternatives before elimination
925	there are 2 alternatives after elimination
926	nameExpr is a
927	decl is a: signed int
928	newExpr is Variable Expression: a: signed int
929
930	alternatives before prune:
931	Cost ( 0, 0, 0 ): Variable Expression: a: signed int
932	(types:
933	lvalue signed int
934	)
935	Environment:
936
937	there are 1 alternatives before elimination
938	there are 1 alternatives after elimination
939	findSubExprs
940	Cost ( 0, 0, 0 ): Variable Expression: a: signed int
941	(types:
942	lvalue signed int
943	)
944	Environment:
945
946	nameExpr is 0
947	decl is 0: signed int
948	newExpr is Variable Expression: 0: signed int
949
950	alternatives before prune:
951	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
952	(types:
953	lvalue signed int
954	)
955	Environment:
956
957	there are 1 alternatives before elimination
958	there are 1 alternatives after elimination
959	findSubExprs
960	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
961	(types:
962	lvalue signed int
963	)
964	Environment:
965
966	working on alternative:
967	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
968	with parameters
969	signed int
970	signed int
971	returning
972	signed int
973
974	(types:
975	pointer to function
976	with parameters
977	signed int
978	signed int
979	returning
980	signed int
981
982	)
983	Environment:
984	formal type is signed int
985	actual type is lvalue signed int
986	formal type is signed int
987	actual type is lvalue signed int
988	need assertions:
989	============= original indexer
990	===idTable===
991	===typeTable===
992	===structTable===
993	===enumTable===
994	===unionTable===
995	===contextTable===
996	============= new indexer
997	===idTable===
998	===typeTable===
999	===structTable===
1000	===enumTable===
1001	===unionTable===
1002	===contextTable===
1003	working on alternative:
1004	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
1005	with parameters
1006	float
1007	float
1008	returning
1009	signed int
1010
1011	(types:
1012	pointer to function
1013	with parameters
1014	float
1015	float
1016	returning
1017	signed int
1018
1019	)
1020	Environment:
1021	formal type is float
1022	actual type is lvalue signed int
1023	formal type is float
1024	actual type is lvalue signed int
1025	need assertions:
1026	============= original indexer
1027	===idTable===
1028	===typeTable===
1029	===structTable===
1030	===enumTable===
1031	===unionTable===
1032	===contextTable===
1033	============= new indexer
1034	===idTable===
1035	===typeTable===
1036	===structTable===
1037	===enumTable===
1038	===unionTable===
1039	===contextTable===
1040	actual expression:
1041	Variable Expression: a: signed int
1042	--- results are
1043	lvalue signed int
1044
1045	converting lvalue signed int
1046	to signed int
1047	cost is( 0, 0, 0 )
1048	actual expression:
1049	Variable Expression: 0: signed int
1050	--- results are
1051	lvalue signed int
1052
1053	converting lvalue signed int
1054	to signed int
1055	cost is( 0, 0, 0 )
1056	Case +++++++++++++
1057	formals are:
1058	signed int
1059	signed int
1060	actuals are:
1061	Variable Expression: a: signed int
1062
1063	Variable Expression: 0: signed int
1064
1065	bindings are:
1066	cost of conversion is:( 0, 0, 0 )
1067	actual expression:
1068	Variable Expression: a: signed int
1069	--- results are
1070	lvalue signed int
1071
1072	converting lvalue signed int
1073	to float
1074	cost is( 0, 0, 5 )
1075	actual expression:
1076	Variable Expression: 0: signed int
1077	--- results are
1078	lvalue signed int
1079
1080	converting lvalue signed int
1081	to float
1082	cost is( 0, 0, 5 )
1083	Case +++++++++++++
1084	formals are:
1085	float
1086	float
1087	actuals are:
1088	Cast of:
1089	Variable Expression: a: signed int
1090
1091	to:
1092	float
1093
1094	Cast of:
1095	Variable Expression: 0: signed int
1096
1097	to:
1098	float
1099
1100	bindings are:
1101	cost of conversion is:( 0, 0, 10 )
1102	alternatives before prune:
1103	Cost ( 0, 0, 0 ): Application of
1104	Variable Expression: ?!=?: function
1105	with parameters
1106	signed int
1107	signed int
1108	returning
1109	signed int
1110
1111	to arguments
1112	Variable Expression: a: signed int
1113
1114	Variable Expression: 0: signed int
1115
1116	(types:
1117	signed int
1118	)
1119	Environment:
1120
1121	Cost ( 0, 0, 10 ): Application of
1122	Variable Expression: ?!=?: function
1123	with parameters
1124	float
1125	float
1126	returning
1127	signed int
1128
1129	to arguments
1130	Cast of:
1131	Variable Expression: a: signed int
1132
1133	to:
1134	float
1135
1136	Cast of:
1137	Variable Expression: 0: signed int
1138
1139	to:
1140	float
1141
1142	(types:
1143	signed int
1144	)
1145	Environment:
1146
1147	there are 1 alternatives before elimination
1148	there are 1 alternatives after elimination
1149	alternatives before prune:
1150	Cost ( 0, 0, 0 ): Cast of:
1151	Application of
1152	Variable Expression: ?!=?: function
1153	with parameters
1154	signed int
1155	signed int
1156	returning
1157	signed int
1158
1159	to arguments
1160	Variable Expression: a: signed int
1161
1162	Variable Expression: 0: signed int
1163
1164
1165	to:
1166	signed int
1167	(types:
1168	signed int
1169	)
1170	Environment:
1171
1172	there are 1 alternatives before elimination
1173	there are 1 alternatives after elimination
1174	nameExpr is ?!=?
1175	decl is ?!=?: function
1176	with parameters
1177	float
1178	float
1179	returning
1180	signed int
1181
1182	newExpr is Variable Expression: ?!=?: function
1183	with parameters
1184	float
1185	float
1186	returning
1187	signed int
1188
1189
1190	decl is ?!=?: function
1191	with parameters
1192	signed int
1193	signed int
1194	returning
1195	signed int
1196
1197	newExpr is Variable Expression: ?!=?: function
1198	with parameters
1199	signed int
1200	signed int
1201	returning
1202	signed int
1203
1204
1205	alternatives before prune:
1206	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
1207	with parameters
1208	float
1209	float
1210	returning
1211	signed int
1212
1213	(types:
1214	pointer to function
1215	with parameters
1216	float
1217	float
1218	returning
1219	signed int
1220
1221	)
1222	Environment:
1223
1224	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
1225	with parameters
1226	signed int
1227	signed int
1228	returning
1229	signed int
1230
1231	(types:
1232	pointer to function
1233	with parameters
1234	signed int
1235	signed int
1236	returning
1237	signed int
1238
1239	)
1240	Environment:
1241
1242	there are 2 alternatives before elimination
1243	there are 2 alternatives after elimination
1244	nameExpr is c
1245	decl is c: float
1246	newExpr is Variable Expression: c: float
1247
1248	alternatives before prune:
1249	Cost ( 0, 0, 0 ): Variable Expression: c: float
1250	(types:
1251	lvalue float
1252	)
1253	Environment:
1254
1255	there are 1 alternatives before elimination
1256	there are 1 alternatives after elimination
1257	findSubExprs
1258	Cost ( 0, 0, 0 ): Variable Expression: c: float
1259	(types:
1260	lvalue float
1261	)
1262	Environment:
1263
1264	nameExpr is 0
1265	decl is 0: signed int
1266	newExpr is Variable Expression: 0: signed int
1267
1268	alternatives before prune:
1269	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
1270	(types:
1271	lvalue signed int
1272	)
1273	Environment:
1274
1275	there are 1 alternatives before elimination
1276	there are 1 alternatives after elimination
1277	findSubExprs
1278	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
1279	(types:
1280	lvalue signed int
1281	)
1282	Environment:
1283
1284	working on alternative:
1285	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
1286	with parameters
1287	signed int
1288	signed int
1289	returning
1290	signed int
1291
1292	(types:
1293	pointer to function
1294	with parameters
1295	signed int
1296	signed int
1297	returning
1298	signed int
1299
1300	)
1301	Environment:
1302	formal type is signed int
1303	actual type is lvalue float
1304	formal type is signed int
1305	actual type is lvalue signed int
1306	need assertions:
1307	============= original indexer
1308	===idTable===
1309	===typeTable===
1310	===structTable===
1311	===enumTable===
1312	===unionTable===
1313	===contextTable===
1314	============= new indexer
1315	===idTable===
1316	===typeTable===
1317	===structTable===
1318	===enumTable===
1319	===unionTable===
1320	===contextTable===
1321	working on alternative:
1322	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
1323	with parameters
1324	float
1325	float
1326	returning
1327	signed int
1328
1329	(types:
1330	pointer to function
1331	with parameters
1332	float
1333	float
1334	returning
1335	signed int
1336
1337	)
1338	Environment:
1339	formal type is float
1340	actual type is lvalue float
1341	formal type is float
1342	actual type is lvalue signed int
1343	need assertions:
1344	============= original indexer
1345	===idTable===
1346	===typeTable===
1347	===structTable===
1348	===enumTable===
1349	===unionTable===
1350	===contextTable===
1351	============= new indexer
1352	===idTable===
1353	===typeTable===
1354	===structTable===
1355	===enumTable===
1356	===unionTable===
1357	===contextTable===
1358	actual expression:
1359	Variable Expression: c: float
1360	--- results are
1361	lvalue float
1362
1363	converting lvalue float
1364	to signed int
1365	cost is( 1, 0, 0 )
1366	actual expression:
1367	Variable Expression: 0: signed int
1368	--- results are
1369	lvalue signed int
1370
1371	converting lvalue signed int
1372	to signed int
1373	cost is( 0, 0, 0 )
1374	Case +++++++++++++
1375	formals are:
1376	signed int
1377	signed int
1378	actuals are:
1379	Cast of:
1380	Variable Expression: c: float
1381
1382	to:
1383	signed int
1384
1385	Variable Expression: 0: signed int
1386
1387	bindings are:
1388	cost of conversion is:( 1, 0, 0 )
1389	actual expression:
1390	Variable Expression: c: float
1391	--- results are
1392	lvalue float
1393
1394	converting lvalue float
1395	to float
1396	cost is( 0, 0, 0 )
1397	actual expression:
1398	Variable Expression: 0: signed int
1399	--- results are
1400	lvalue signed int
1401
1402	converting lvalue signed int
1403	to float
1404	cost is( 0, 0, 5 )
1405	Case +++++++++++++
1406	formals are:
1407	float
1408	float
1409	actuals are:
1410	Variable Expression: c: float
1411
1412	Cast of:
1413	Variable Expression: 0: signed int
1414
1415	to:
1416	float
1417
1418	bindings are:
1419	cost of conversion is:( 0, 0, 5 )
1420	alternatives before prune:
1421	Cost ( 1, 0, 0 ): Application of
1422	Variable Expression: ?!=?: function
1423	with parameters
1424	signed int
1425	signed int
1426	returning
1427	signed int
1428
1429	to arguments
1430	Cast of:
1431	Variable Expression: c: float
1432
1433	to:
1434	signed int
1435
1436	Variable Expression: 0: signed int
1437
1438	(types:
1439	signed int
1440	)
1441	Environment:
1442
1443	Cost ( 0, 0, 5 ): Application of
1444	Variable Expression: ?!=?: function
1445	with parameters
1446	float
1447	float
1448	returning
1449	signed int
1450
1451	to arguments
1452	Variable Expression: c: float
1453
1454	Cast of:
1455	Variable Expression: 0: signed int
1456
1457	to:
1458	float
1459
1460	(types:
1461	signed int
1462	)
1463	Environment:
1464
1465	cost ( 0, 0, 5 ) beats ( 1, 0, 0 )
1466	there are 1 alternatives before elimination
1467	there are 1 alternatives after elimination
1468	alternatives before prune:
1469	Cost ( 0, 0, 0 ): Cast of:
1470	Application of
1471	Variable Expression: ?!=?: function
1472	with parameters
1473	float
1474	float
1475	returning
1476	signed int
1477
1478	to arguments
1479	Variable Expression: c: float
1480
1481	Cast of:
1482	Variable Expression: 0: signed int
1483
1484	to:
1485	float
1486
1487
1488	to:
1489	signed int
1490	(types:
1491	signed int
1492	)
1493	Environment:
1494
1495	there are 1 alternatives before elimination
1496	there are 1 alternatives after elimination
1497	alternatives before prune:
1498	Cost ( 0, 0, 0 ): Short-circuited operation (and) on: Cast of:
1499	Application of
1500	Variable Expression: ?!=?: function
1501	with parameters
1502	signed int
1503	signed int
1504	returning
1505	signed int
1506
1507	to arguments
1508	Variable Expression: a: signed int
1509
1510	Variable Expression: 0: signed int
1511
1512
1513	to:
1514	signed int
1515	and Cast of:
1516	Application of
1517	Variable Expression: ?!=?: function
1518	with parameters
1519	float
1520	float
1521	returning
1522	signed int
1523
1524	to arguments
1525	Variable Expression: c: float
1526
1527	Cast of:
1528	Variable Expression: 0: signed int
1529
1530	to:
1531	float
1532
1533
1534	to:
1535	signed int
1536
1537	(types:
1538	signed int
1539	)
1540	Environment:
1541
1542	there are 1 alternatives before elimination
1543	there are 1 alternatives after elimination
1544	findSubExprs
1545	Cost ( 0, 0, 0 ): Short-circuited operation (and) on: Cast of:
1546	Application of
1547	Variable Expression: ?!=?: function
1548	with parameters
1549	signed int
1550	signed int
1551	returning
1552	signed int
1553
1554	to arguments
1555	Variable Expression: a: signed int
1556
1557	Variable Expression: 0: signed int
1558
1559
1560	to:
1561	signed int
1562	and Cast of:
1563	Application of
1564	Variable Expression: ?!=?: function
1565	with parameters
1566	float
1567	float
1568	returning
1569	signed int
1570
1571	to arguments
1572	Variable Expression: c: float
1573
1574	Cast of:
1575	Variable Expression: 0: signed int
1576
1577	to:
1578	float
1579
1580
1581	to:
1582	signed int
1583
1584	(types:
1585	signed int
1586	)
1587	Environment:
1588
1589	working on alternative:
1590	Cost ( 0, 0, 0 ): Variable Expression: g: function
1591	with parameters
1592	signed int
1593	returning
1594	nothing
1595
1596	(types:
1597	pointer to function
1598	with parameters
1599	signed int
1600	returning
1601	nothing
1602
1603	)
1604	Environment:
1605	formal type is signed int
1606	actual type is signed int
1607	need assertions:
1608	============= original indexer
1609	===idTable===
1610	===typeTable===
1611	===structTable===
1612	===enumTable===
1613	===unionTable===
1614	===contextTable===
1615	============= new indexer
1616	===idTable===
1617	===typeTable===
1618	===structTable===
1619	===enumTable===
1620	===unionTable===
1621	===contextTable===
1622	working on alternative:
1623	Cost ( 0, 0, 0 ): Variable Expression: g: function
1624	with parameters
1625	float
1626	returning
1627	nothing
1628
1629	(types:
1630	pointer to function
1631	with parameters
1632	float
1633	returning
1634	nothing
1635
1636	)
1637	Environment:
1638	formal type is float
1639	actual type is signed int
1640	need assertions:
1641	============= original indexer
1642	===idTable===
1643	===typeTable===
1644	===structTable===
1645	===enumTable===
1646	===unionTable===
1647	===contextTable===
1648	============= new indexer
1649	===idTable===
1650	===typeTable===
1651	===structTable===
1652	===enumTable===
1653	===unionTable===
1654	===contextTable===
1655	actual expression:
1656	Short-circuited operation (and) on: Cast of:
1657	Application of
1658	Variable Expression: ?!=?: function
1659	with parameters
1660	signed int
1661	signed int
1662	returning
1663	signed int
1664
1665	to arguments
1666	Variable Expression: a: signed int
1667
1668	Variable Expression: 0: signed int
1669
1670
1671	to:
1672	signed int
1673	and Cast of:
1674	Application of
1675	Variable Expression: ?!=?: function
1676	with parameters
1677	float
1678	float
1679	returning
1680	signed int
1681
1682	to arguments
1683	Variable Expression: c: float
1684
1685	Cast of:
1686	Variable Expression: 0: signed int
1687
1688	to:
1689	float
1690
1691
1692	to:
1693	signed int
1694
1695	--- results are
1696	signed int
1697
1698	converting signed int
1699	to signed int
1700	cost is( 0, 0, 0 )
1701	Case +++++++++++++
1702	formals are:
1703	signed int
1704	actuals are:
1705	Short-circuited operation (and) on: Cast of:
1706	Application of
1707	Variable Expression: ?!=?: function
1708	with parameters
1709	signed int
1710	signed int
1711	returning
1712	signed int
1713
1714	to arguments
1715	Variable Expression: a: signed int
1716
1717	Variable Expression: 0: signed int
1718
1719
1720	to:
1721	signed int
1722	and Cast of:
1723	Application of
1724	Variable Expression: ?!=?: function
1725	with parameters
1726	float
1727	float
1728	returning
1729	signed int
1730
1731	to arguments
1732	Variable Expression: c: float
1733
1734	Cast of:
1735	Variable Expression: 0: signed int
1736
1737	to:
1738	float
1739
1740
1741	to:
1742	signed int
1743
1744
1745	bindings are:
1746	cost of conversion is:( 0, 0, 0 )
1747	actual expression:
1748	Short-circuited operation (and) on: Cast of:
1749	Application of
1750	Variable Expression: ?!=?: function
1751	with parameters
1752	signed int
1753	signed int
1754	returning
1755	signed int
1756
1757	to arguments
1758	Variable Expression: a: signed int
1759
1760	Variable Expression: 0: signed int
1761
1762
1763	to:
1764	signed int
1765	and Cast of:
1766	Application of
1767	Variable Expression: ?!=?: function
1768	with parameters
1769	float
1770	float
1771	returning
1772	signed int
1773
1774	to arguments
1775	Variable Expression: c: float
1776
1777	Cast of:
1778	Variable Expression: 0: signed int
1779
1780	to:
1781	float
1782
1783
1784	to:
1785	signed int
1786
1787	--- results are
1788	signed int
1789
1790	converting signed int
1791	to float
1792	cost is( 0, 0, 5 )
1793	Case +++++++++++++
1794	formals are:
1795	float
1796	actuals are:
1797	Cast of:
1798	Short-circuited operation (and) on: Cast of:
1799	Application of
1800	Variable Expression: ?!=?: function
1801	with parameters
1802	signed int
1803	signed int
1804	returning
1805	signed int
1806
1807	to arguments
1808	Variable Expression: a: signed int
1809
1810	Variable Expression: 0: signed int
1811
1812
1813	to:
1814	signed int
1815	and Cast of:
1816	Application of
1817	Variable Expression: ?!=?: function
1818	with parameters
1819	float
1820	float
1821	returning
1822	signed int
1823
1824	to arguments
1825	Variable Expression: c: float
1826
1827	Cast of:
1828	Variable Expression: 0: signed int
1829
1830	to:
1831	float
1832
1833
1834	to:
1835	signed int
1836
1837
1838	to:
1839	float
1840
1841	bindings are:
1842	cost of conversion is:( 0, 0, 5 )
1843	alternatives before prune:
1844	Cost ( 0, 0, 0 ): Application of
1845	Variable Expression: g: function
1846	with parameters
1847	signed int
1848	returning
1849	nothing
1850
1851	to arguments
1852	Short-circuited operation (and) on: Cast of:
1853	Application of
1854	Variable Expression: ?!=?: function
1855	with parameters
1856	signed int
1857	signed int
1858	returning
1859	signed int
1860
1861	to arguments
1862	Variable Expression: a: signed int
1863
1864	Variable Expression: 0: signed int
1865
1866
1867	to:
1868	signed int
1869	and Cast of:
1870	Application of
1871	Variable Expression: ?!=?: function
1872	with parameters
1873	float
1874	float
1875	returning
1876	signed int
1877
1878	to arguments
1879	Variable Expression: c: float
1880
1881	Cast of:
1882	Variable Expression: 0: signed int
1883
1884	to:
1885	float
1886
1887
1888	to:
1889	signed int
1890
1891
1892	(types:
1893	)
1894	Environment:
1895
1896	Cost ( 0, 0, 5 ): Application of
1897	Variable Expression: g: function
1898	with parameters
1899	float
1900	returning
1901	nothing
1902
1903	to arguments
1904	Cast of:
1905	Short-circuited operation (and) on: Cast of:
1906	Application of
1907	Variable Expression: ?!=?: function
1908	with parameters
1909	signed int
1910	signed int
1911	returning
1912	signed int
1913
1914	to arguments
1915	Variable Expression: a: signed int
1916
1917	Variable Expression: 0: signed int
1918
1919
1920	to:
1921	signed int
1922	and Cast of:
1923	Application of
1924	Variable Expression: ?!=?: function
1925	with parameters
1926	float
1927	float
1928	returning
1929	signed int
1930
1931	to arguments
1932	Variable Expression: c: float
1933
1934	Cast of:
1935	Variable Expression: 0: signed int
1936
1937	to:
1938	float
1939
1940
1941	to:
1942	signed int
1943
1944
1945	to:
1946	float
1947
1948	(types:
1949	)
1950	Environment:
1951
1952	there are 1 alternatives before elimination
1953	there are 1 alternatives after elimination
1954	alternatives before prune:
1955	Cost ( 0, 0, 0 ): Cast of:
1956	Application of
1957	Variable Expression: g: function
1958	with parameters
1959	signed int
1960	returning
1961	nothing
1962
1963	to arguments
1964	Short-circuited operation (and) on: Cast of:
1965	Application of
1966	Variable Expression: ?!=?: function
1967	with parameters
1968	signed int
1969	signed int
1970	returning
1971	signed int
1972
1973	to arguments
1974	Variable Expression: a: signed int
1975
1976	Variable Expression: 0: signed int
1977
1978
1979	to:
1980	signed int
1981	and Cast of:
1982	Application of
1983	Variable Expression: ?!=?: function
1984	with parameters
1985	float
1986	float
1987	returning
1988	signed int
1989
1990	to arguments
1991	Variable Expression: c: float
1992
1993	Cast of:
1994	Variable Expression: 0: signed int
1995
1996	to:
1997	float
1998
1999
2000	to:
2001	signed int
2002
2003
2004
2005	to:
2006	nothing
2007	(types:
2008	)
2009	Environment:
2010
2011	there are 1 alternatives before elimination
2012	there are 1 alternatives after elimination
2013	nameExpr is g
2014	decl is g: function
2015	with parameters
2016	float
2017	returning
2018	nothing
2019
2020	newExpr is Variable Expression: g: function
2021	with parameters
2022	float
2023	returning
2024	nothing
2025
2026
2027	decl is g: function
2028	with parameters
2029	signed int
2030	returning
2031	nothing
2032
2033	newExpr is Variable Expression: g: function
2034	with parameters
2035	signed int
2036	returning
2037	nothing
2038
2039
2040	alternatives before prune:
2041	Cost ( 0, 0, 0 ): Variable Expression: g: function
2042	with parameters
2043	float
2044	returning
2045	nothing
2046
2047	(types:
2048	pointer to function
2049	with parameters
2050	float
2051	returning
2052	nothing
2053
2054	)
2055	Environment:
2056
2057	Cost ( 0, 0, 0 ): Variable Expression: g: function
2058	with parameters
2059	signed int
2060	returning
2061	nothing
2062
2063	(types:
2064	pointer to function
2065	with parameters
2066	signed int
2067	returning
2068	nothing
2069
2070	)
2071	Environment:
2072
2073	there are 2 alternatives before elimination
2074	there are 2 alternatives after elimination
2075	nameExpr is ?!=?
2076	decl is ?!=?: function
2077	with parameters
2078	float
2079	float
2080	returning
2081	signed int
2082
2083	newExpr is Variable Expression: ?!=?: function
2084	with parameters
2085	float
2086	float
2087	returning
2088	signed int
2089
2090
2091	decl is ?!=?: function
2092	with parameters
2093	signed int
2094	signed int
2095	returning
2096	signed int
2097
2098	newExpr is Variable Expression: ?!=?: function
2099	with parameters
2100	signed int
2101	signed int
2102	returning
2103	signed int
2104
2105
2106	alternatives before prune:
2107	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
2108	with parameters
2109	float
2110	float
2111	returning
2112	signed int
2113
2114	(types:
2115	pointer to function
2116	with parameters
2117	float
2118	float
2119	returning
2120	signed int
2121
2122	)
2123	Environment:
2124
2125	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
2126	with parameters
2127	signed int
2128	signed int
2129	returning
2130	signed int
2131
2132	(types:
2133	pointer to function
2134	with parameters
2135	signed int
2136	signed int
2137	returning
2138	signed int
2139
2140	)
2141	Environment:
2142
2143	there are 2 alternatives before elimination
2144	there are 2 alternatives after elimination
2145	nameExpr is a
2146	decl is a: signed int
2147	newExpr is Variable Expression: a: signed int
2148
2149	alternatives before prune:
2150	Cost ( 0, 0, 0 ): Variable Expression: a: signed int
2151	(types:
2152	lvalue signed int
2153	)
2154	Environment:
2155
2156	there are 1 alternatives before elimination
2157	there are 1 alternatives after elimination
2158	findSubExprs
2159	Cost ( 0, 0, 0 ): Variable Expression: a: signed int
2160	(types:
2161	lvalue signed int
2162	)
2163	Environment:
2164
2165	nameExpr is 0
2166	decl is 0: signed int
2167	newExpr is Variable Expression: 0: signed int
2168
2169	alternatives before prune:
2170	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
2171	(types:
2172	lvalue signed int
2173	)
2174	Environment:
2175
2176	there are 1 alternatives before elimination
2177	there are 1 alternatives after elimination
2178	findSubExprs
2179	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
2180	(types:
2181	lvalue signed int
2182	)
2183	Environment:
2184
2185	working on alternative:
2186	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
2187	with parameters
2188	signed int
2189	signed int
2190	returning
2191	signed int
2192
2193	(types:
2194	pointer to function
2195	with parameters
2196	signed int
2197	signed int
2198	returning
2199	signed int
2200
2201	)
2202	Environment:
2203	formal type is signed int
2204	actual type is lvalue signed int
2205	formal type is signed int
2206	actual type is lvalue signed int
2207	need assertions:
2208	============= original indexer
2209	===idTable===
2210	===typeTable===
2211	===structTable===
2212	===enumTable===
2213	===unionTable===
2214	===contextTable===
2215	============= new indexer
2216	===idTable===
2217	===typeTable===
2218	===structTable===
2219	===enumTable===
2220	===unionTable===
2221	===contextTable===
2222	working on alternative:
2223	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
2224	with parameters
2225	float
2226	float
2227	returning
2228	signed int
2229
2230	(types:
2231	pointer to function
2232	with parameters
2233	float
2234	float
2235	returning
2236	signed int
2237
2238	)
2239	Environment:
2240	formal type is float
2241	actual type is lvalue signed int
2242	formal type is float
2243	actual type is lvalue signed int
2244	need assertions:
2245	============= original indexer
2246	===idTable===
2247	===typeTable===
2248	===structTable===
2249	===enumTable===
2250	===unionTable===
2251	===contextTable===
2252	============= new indexer
2253	===idTable===
2254	===typeTable===
2255	===structTable===
2256	===enumTable===
2257	===unionTable===
2258	===contextTable===
2259	actual expression:
2260	Variable Expression: a: signed int
2261	--- results are
2262	lvalue signed int
2263
2264	converting lvalue signed int
2265	to signed int
2266	cost is( 0, 0, 0 )
2267	actual expression:
2268	Variable Expression: 0: signed int
2269	--- results are
2270	lvalue signed int
2271
2272	converting lvalue signed int
2273	to signed int
2274	cost is( 0, 0, 0 )
2275	Case +++++++++++++
2276	formals are:
2277	signed int
2278	signed int
2279	actuals are:
2280	Variable Expression: a: signed int
2281
2282	Variable Expression: 0: signed int
2283
2284	bindings are:
2285	cost of conversion is:( 0, 0, 0 )
2286	actual expression:
2287	Variable Expression: a: signed int
2288	--- results are
2289	lvalue signed int
2290
2291	converting lvalue signed int
2292	to float
2293	cost is( 0, 0, 5 )
2294	actual expression:
2295	Variable Expression: 0: signed int
2296	--- results are
2297	lvalue signed int
2298
2299	converting lvalue signed int
2300	to float
2301	cost is( 0, 0, 5 )
2302	Case +++++++++++++
2303	formals are:
2304	float
2305	float
2306	actuals are:
2307	Cast of:
2308	Variable Expression: a: signed int
2309
2310	to:
2311	float
2312
2313	Cast of:
2314	Variable Expression: 0: signed int
2315
2316	to:
2317	float
2318
2319	bindings are:
2320	cost of conversion is:( 0, 0, 10 )
2321	alternatives before prune:
2322	Cost ( 0, 0, 0 ): Application of
2323	Variable Expression: ?!=?: function
2324	with parameters
2325	signed int
2326	signed int
2327	returning
2328	signed int
2329
2330	to arguments
2331	Variable Expression: a: signed int
2332
2333	Variable Expression: 0: signed int
2334
2335	(types:
2336	signed int
2337	)
2338	Environment:
2339
2340	Cost ( 0, 0, 10 ): Application of
2341	Variable Expression: ?!=?: function
2342	with parameters
2343	float
2344	float
2345	returning
2346	signed int
2347
2348	to arguments
2349	Cast of:
2350	Variable Expression: a: signed int
2351
2352	to:
2353	float
2354
2355	Cast of:
2356	Variable Expression: 0: signed int
2357
2358	to:
2359	float
2360
2361	(types:
2362	signed int
2363	)
2364	Environment:
2365
2366	there are 1 alternatives before elimination
2367	there are 1 alternatives after elimination
2368	alternatives before prune:
2369	Cost ( 0, 0, 0 ): Cast of:
2370	Application of
2371	Variable Expression: ?!=?: function
2372	with parameters
2373	signed int
2374	signed int
2375	returning
2376	signed int
2377
2378	to arguments
2379	Variable Expression: a: signed int
2380
2381	Variable Expression: 0: signed int
2382
2383
2384	to:
2385	signed int
2386	(types:
2387	signed int
2388	)
2389	Environment:
2390
2391	there are 1 alternatives before elimination
2392	there are 1 alternatives after elimination
2393	nameExpr is ?!=?
2394	decl is ?!=?: function
2395	with parameters
2396	float
2397	float
2398	returning
2399	signed int
2400
2401	newExpr is Variable Expression: ?!=?: function
2402	with parameters
2403	float
2404	float
2405	returning
2406	signed int
2407
2408
2409	decl is ?!=?: function
2410	with parameters
2411	signed int
2412	signed int
2413	returning
2414	signed int
2415
2416	newExpr is Variable Expression: ?!=?: function
2417	with parameters
2418	signed int
2419	signed int
2420	returning
2421	signed int
2422
2423
2424	alternatives before prune:
2425	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
2426	with parameters
2427	float
2428	float
2429	returning
2430	signed int
2431
2432	(types:
2433	pointer to function
2434	with parameters
2435	float
2436	float
2437	returning
2438	signed int
2439
2440	)
2441	Environment:
2442
2443	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
2444	with parameters
2445	signed int
2446	signed int
2447	returning
2448	signed int
2449
2450	(types:
2451	pointer to function
2452	with parameters
2453	signed int
2454	signed int
2455	returning
2456	signed int
2457
2458	)
2459	Environment:
2460
2461	there are 2 alternatives before elimination
2462	there are 2 alternatives after elimination
2463	nameExpr is b
2464	decl is b: signed int
2465	newExpr is Variable Expression: b: signed int
2466
2467	alternatives before prune:
2468	Cost ( 0, 0, 0 ): Variable Expression: b: signed int
2469	(types:
2470	lvalue signed int
2471	)
2472	Environment:
2473
2474	there are 1 alternatives before elimination
2475	there are 1 alternatives after elimination
2476	findSubExprs
2477	Cost ( 0, 0, 0 ): Variable Expression: b: signed int
2478	(types:
2479	lvalue signed int
2480	)
2481	Environment:
2482
2483	nameExpr is 0
2484	decl is 0: signed int
2485	newExpr is Variable Expression: 0: signed int
2486
2487	alternatives before prune:
2488	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
2489	(types:
2490	lvalue signed int
2491	)
2492	Environment:
2493
2494	there are 1 alternatives before elimination
2495	there are 1 alternatives after elimination
2496	findSubExprs
2497	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
2498	(types:
2499	lvalue signed int
2500	)
2501	Environment:
2502
2503	working on alternative:
2504	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
2505	with parameters
2506	signed int
2507	signed int
2508	returning
2509	signed int
2510
2511	(types:
2512	pointer to function
2513	with parameters
2514	signed int
2515	signed int
2516	returning
2517	signed int
2518
2519	)
2520	Environment:
2521	formal type is signed int
2522	actual type is lvalue signed int
2523	formal type is signed int
2524	actual type is lvalue signed int
2525	need assertions:
2526	============= original indexer
2527	===idTable===
2528	===typeTable===
2529	===structTable===
2530	===enumTable===
2531	===unionTable===
2532	===contextTable===
2533	============= new indexer
2534	===idTable===
2535	===typeTable===
2536	===structTable===
2537	===enumTable===
2538	===unionTable===
2539	===contextTable===
2540	working on alternative:
2541	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
2542	with parameters
2543	float
2544	float
2545	returning
2546	signed int
2547
2548	(types:
2549	pointer to function
2550	with parameters
2551	float
2552	float
2553	returning
2554	signed int
2555
2556	)
2557	Environment:
2558	formal type is float
2559	actual type is lvalue signed int
2560	formal type is float
2561	actual type is lvalue signed int
2562	need assertions:
2563	============= original indexer
2564	===idTable===
2565	===typeTable===
2566	===structTable===
2567	===enumTable===
2568	===unionTable===
2569	===contextTable===
2570	============= new indexer
2571	===idTable===
2572	===typeTable===
2573	===structTable===
2574	===enumTable===
2575	===unionTable===
2576	===contextTable===
2577	actual expression:
2578	Variable Expression: b: signed int
2579	--- results are
2580	lvalue signed int
2581
2582	converting lvalue signed int
2583	to signed int
2584	cost is( 0, 0, 0 )
2585	actual expression:
2586	Variable Expression: 0: signed int
2587	--- results are
2588	lvalue signed int
2589
2590	converting lvalue signed int
2591	to signed int
2592	cost is( 0, 0, 0 )
2593	Case +++++++++++++
2594	formals are:
2595	signed int
2596	signed int
2597	actuals are:
2598	Variable Expression: b: signed int
2599
2600	Variable Expression: 0: signed int
2601
2602	bindings are:
2603	cost of conversion is:( 0, 0, 0 )
2604	actual expression:
2605	Variable Expression: b: signed int
2606	--- results are
2607	lvalue signed int
2608
2609	converting lvalue signed int
2610	to float
2611	cost is( 0, 0, 5 )
2612	actual expression:
2613	Variable Expression: 0: signed int
2614	--- results are
2615	lvalue signed int
2616
2617	converting lvalue signed int
2618	to float
2619	cost is( 0, 0, 5 )
2620	Case +++++++++++++
2621	formals are:
2622	float
2623	float
2624	actuals are:
2625	Cast of:
2626	Variable Expression: b: signed int
2627
2628	to:
2629	float
2630
2631	Cast of:
2632	Variable Expression: 0: signed int
2633
2634	to:
2635	float
2636
2637	bindings are:
2638	cost of conversion is:( 0, 0, 10 )
2639	alternatives before prune:
2640	Cost ( 0, 0, 0 ): Application of
2641	Variable Expression: ?!=?: function
2642	with parameters
2643	signed int
2644	signed int
2645	returning
2646	signed int
2647
2648	to arguments
2649	Variable Expression: b: signed int
2650
2651	Variable Expression: 0: signed int
2652
2653	(types:
2654	signed int
2655	)
2656	Environment:
2657
2658	Cost ( 0, 0, 10 ): Application of
2659	Variable Expression: ?!=?: function
2660	with parameters
2661	float
2662	float
2663	returning
2664	signed int
2665
2666	to arguments
2667	Cast of:
2668	Variable Expression: b: signed int
2669
2670	to:
2671	float
2672
2673	Cast of:
2674	Variable Expression: 0: signed int
2675
2676	to:
2677	float
2678
2679	(types:
2680	signed int
2681	)
2682	Environment:
2683
2684	there are 1 alternatives before elimination
2685	there are 1 alternatives after elimination
2686	alternatives before prune:
2687	Cost ( 0, 0, 0 ): Cast of:
2688	Application of
2689	Variable Expression: ?!=?: function
2690	with parameters
2691	signed int
2692	signed int
2693	returning
2694	signed int
2695
2696	to arguments
2697	Variable Expression: b: signed int
2698
2699	Variable Expression: 0: signed int
2700
2701
2702	to:
2703	signed int
2704	(types:
2705	signed int
2706	)
2707	Environment:
2708
2709	there are 1 alternatives before elimination
2710	there are 1 alternatives after elimination
2711	alternatives before prune:
2712	Cost ( 0, 0, 0 ): Short-circuited operation (or) on: Cast of:
2713	Application of
2714	Variable Expression: ?!=?: function
2715	with parameters
2716	signed int
2717	signed int
2718	returning
2719	signed int
2720
2721	to arguments
2722	Variable Expression: a: signed int
2723
2724	Variable Expression: 0: signed int
2725
2726
2727	to:
2728	signed int
2729	and Cast of:
2730	Application of
2731	Variable Expression: ?!=?: function
2732	with parameters
2733	signed int
2734	signed int
2735	returning
2736	signed int
2737
2738	to arguments
2739	Variable Expression: b: signed int
2740
2741	Variable Expression: 0: signed int
2742
2743
2744	to:
2745	signed int
2746
2747	(types:
2748	signed int
2749	)
2750	Environment:
2751
2752	there are 1 alternatives before elimination
2753	there are 1 alternatives after elimination
2754	findSubExprs
2755	Cost ( 0, 0, 0 ): Short-circuited operation (or) on: Cast of:
2756	Application of
2757	Variable Expression: ?!=?: function
2758	with parameters
2759	signed int
2760	signed int
2761	returning
2762	signed int
2763
2764	to arguments
2765	Variable Expression: a: signed int
2766
2767	Variable Expression: 0: signed int
2768
2769
2770	to:
2771	signed int
2772	and Cast of:
2773	Application of
2774	Variable Expression: ?!=?: function
2775	with parameters
2776	signed int
2777	signed int
2778	returning
2779	signed int
2780
2781	to arguments
2782	Variable Expression: b: signed int
2783
2784	Variable Expression: 0: signed int
2785
2786
2787	to:
2788	signed int
2789
2790	(types:
2791	signed int
2792	)
2793	Environment:
2794
2795	working on alternative:
2796	Cost ( 0, 0, 0 ): Variable Expression: g: function
2797	with parameters
2798	signed int
2799	returning
2800	nothing
2801
2802	(types:
2803	pointer to function
2804	with parameters
2805	signed int
2806	returning
2807	nothing
2808
2809	)
2810	Environment:
2811	formal type is signed int
2812	actual type is signed int
2813	need assertions:
2814	============= original indexer
2815	===idTable===
2816	===typeTable===
2817	===structTable===
2818	===enumTable===
2819	===unionTable===
2820	===contextTable===
2821	============= new indexer
2822	===idTable===
2823	===typeTable===
2824	===structTable===
2825	===enumTable===
2826	===unionTable===
2827	===contextTable===
2828	working on alternative:
2829	Cost ( 0, 0, 0 ): Variable Expression: g: function
2830	with parameters
2831	float
2832	returning
2833	nothing
2834
2835	(types:
2836	pointer to function
2837	with parameters
2838	float
2839	returning
2840	nothing
2841
2842	)
2843	Environment:
2844	formal type is float
2845	actual type is signed int
2846	need assertions:
2847	============= original indexer
2848	===idTable===
2849	===typeTable===
2850	===structTable===
2851	===enumTable===
2852	===unionTable===
2853	===contextTable===
2854	============= new indexer
2855	===idTable===
2856	===typeTable===
2857	===structTable===
2858	===enumTable===
2859	===unionTable===
2860	===contextTable===
2861	actual expression:
2862	Short-circuited operation (or) on: Cast of:
2863	Application of
2864	Variable Expression: ?!=?: function
2865	with parameters
2866	signed int
2867	signed int
2868	returning
2869	signed int
2870
2871	to arguments
2872	Variable Expression: a: signed int
2873
2874	Variable Expression: 0: signed int
2875
2876
2877	to:
2878	signed int
2879	and Cast of:
2880	Application of
2881	Variable Expression: ?!=?: function
2882	with parameters
2883	signed int
2884	signed int
2885	returning
2886	signed int
2887
2888	to arguments
2889	Variable Expression: b: signed int
2890
2891	Variable Expression: 0: signed int
2892
2893
2894	to:
2895	signed int
2896
2897	--- results are
2898	signed int
2899
2900	converting signed int
2901	to signed int
2902	cost is( 0, 0, 0 )
2903	Case +++++++++++++
2904	formals are:
2905	signed int
2906	actuals are:
2907	Short-circuited operation (or) on: Cast of:
2908	Application of
2909	Variable Expression: ?!=?: function
2910	with parameters
2911	signed int
2912	signed int
2913	returning
2914	signed int
2915
2916	to arguments
2917	Variable Expression: a: signed int
2918
2919	Variable Expression: 0: signed int
2920
2921
2922	to:
2923	signed int
2924	and Cast of:
2925	Application of
2926	Variable Expression: ?!=?: function
2927	with parameters
2928	signed int
2929	signed int
2930	returning
2931	signed int
2932
2933	to arguments
2934	Variable Expression: b: signed int
2935
2936	Variable Expression: 0: signed int
2937
2938
2939	to:
2940	signed int
2941
2942
2943	bindings are:
2944	cost of conversion is:( 0, 0, 0 )
2945	actual expression:
2946	Short-circuited operation (or) on: Cast of:
2947	Application of
2948	Variable Expression: ?!=?: function
2949	with parameters
2950	signed int
2951	signed int
2952	returning
2953	signed int
2954
2955	to arguments
2956	Variable Expression: a: signed int
2957
2958	Variable Expression: 0: signed int
2959
2960
2961	to:
2962	signed int
2963	and Cast of:
2964	Application of
2965	Variable Expression: ?!=?: function
2966	with parameters
2967	signed int
2968	signed int
2969	returning
2970	signed int
2971
2972	to arguments
2973	Variable Expression: b: signed int
2974
2975	Variable Expression: 0: signed int
2976
2977
2978	to:
2979	signed int
2980
2981	--- results are
2982	signed int
2983
2984	converting signed int
2985	to float
2986	cost is( 0, 0, 5 )
2987	Case +++++++++++++
2988	formals are:
2989	float
2990	actuals are:
2991	Cast of:
2992	Short-circuited operation (or) on: Cast of:
2993	Application of
2994	Variable Expression: ?!=?: function
2995	with parameters
2996	signed int
2997	signed int
2998	returning
2999	signed int
3000
3001	to arguments
3002	Variable Expression: a: signed int
3003
3004	Variable Expression: 0: signed int
3005
3006
3007	to:
3008	signed int
3009	and Cast of:
3010	Application of
3011	Variable Expression: ?!=?: function
3012	with parameters
3013	signed int
3014	signed int
3015	returning
3016	signed int
3017
3018	to arguments
3019	Variable Expression: b: signed int
3020
3021	Variable Expression: 0: signed int
3022
3023
3024	to:
3025	signed int
3026
3027
3028	to:
3029	float
3030
3031	bindings are:
3032	cost of conversion is:( 0, 0, 5 )
3033	alternatives before prune:
3034	Cost ( 0, 0, 0 ): Application of
3035	Variable Expression: g: function
3036	with parameters
3037	signed int
3038	returning
3039	nothing
3040
3041	to arguments
3042	Short-circuited operation (or) on: Cast of:
3043	Application of
3044	Variable Expression: ?!=?: function
3045	with parameters
3046	signed int
3047	signed int
3048	returning
3049	signed int
3050
3051	to arguments
3052	Variable Expression: a: signed int
3053
3054	Variable Expression: 0: signed int
3055
3056
3057	to:
3058	signed int
3059	and Cast of:
3060	Application of
3061	Variable Expression: ?!=?: function
3062	with parameters
3063	signed int
3064	signed int
3065	returning
3066	signed int
3067
3068	to arguments
3069	Variable Expression: b: signed int
3070
3071	Variable Expression: 0: signed int
3072
3073
3074	to:
3075	signed int
3076
3077
3078	(types:
3079	)
3080	Environment:
3081
3082	Cost ( 0, 0, 5 ): Application of
3083	Variable Expression: g: function
3084	with parameters
3085	float
3086	returning
3087	nothing
3088
3089	to arguments
3090	Cast of:
3091	Short-circuited operation (or) on: Cast of:
3092	Application of
3093	Variable Expression: ?!=?: function
3094	with parameters
3095	signed int
3096	signed int
3097	returning
3098	signed int
3099
3100	to arguments
3101	Variable Expression: a: signed int
3102
3103	Variable Expression: 0: signed int
3104
3105
3106	to:
3107	signed int
3108	and Cast of:
3109	Application of
3110	Variable Expression: ?!=?: function
3111	with parameters
3112	signed int
3113	signed int
3114	returning
3115	signed int
3116
3117	to arguments
3118	Variable Expression: b: signed int
3119
3120	Variable Expression: 0: signed int
3121
3122
3123	to:
3124	signed int
3125
3126
3127	to:
3128	float
3129
3130	(types:
3131	)
3132	Environment:
3133
3134	there are 1 alternatives before elimination
3135	there are 1 alternatives after elimination
3136	alternatives before prune:
3137	Cost ( 0, 0, 0 ): Cast of:
3138	Application of
3139	Variable Expression: g: function
3140	with parameters
3141	signed int
3142	returning
3143	nothing
3144
3145	to arguments
3146	Short-circuited operation (or) on: Cast of:
3147	Application of
3148	Variable Expression: ?!=?: function
3149	with parameters
3150	signed int
3151	signed int
3152	returning
3153	signed int
3154
3155	to arguments
3156	Variable Expression: a: signed int
3157
3158	Variable Expression: 0: signed int
3159
3160
3161	to:
3162	signed int
3163	and Cast of:
3164	Application of
3165	Variable Expression: ?!=?: function
3166	with parameters
3167	signed int
3168	signed int
3169	returning
3170	signed int
3171
3172	to arguments
3173	Variable Expression: b: signed int
3174
3175	Variable Expression: 0: signed int
3176
3177
3178	to:
3179	signed int
3180
3181
3182
3183	to:
3184	nothing
3185	(types:
3186	)
3187	Environment:
3188
3189	there are 1 alternatives before elimination
3190	there are 1 alternatives after elimination
3191	int ___operator_notequal__Fi_ii_(int , int );
3192	int ___operator_notequal__Fi_ff_(float , float );
3193	int ___constant_zero__i;
3194	void __g__F_f_(float );
3195	void __g__F_i_(int );
3196	void __f__F_i_(int __a__i){
3197	int __b__i;
3198	float __c__f;
3199	__g__F_f_((((int )___operator_notequal__Fi_ii_(__a__i, ___constant_zero__i)) ? __b__i : __c__f));
3200	__g__F_i_((((int )___operator_notequal__Fi_ii_(__a__i, ___constant_zero__i)) && ((int )___operator_notequal__Fi_ff_(__c__f, ((float )___constant_zero__i)))));
3201	__g__F_i_((((int )___operator_notequal__Fi_ii_(__a__i, ___constant_zero__i)) \|\| ((int )___operator_notequal__Fi_ii_(__b__i, ___constant_zero__i))));
3202	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: