Context Navigation

source: src/Tests/Expect-r/Misc.txt @ 356189a

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsctordeferred_resndemanglerenumforall-pointer-decaygc_noraiijacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc

Last change on this file since 356189a was b1d6dd5, checked in by Peter A. Buhr <pabuhr@…>, 9 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: 29.0 KB

Line
1	nameExpr is g
2	decl is g: function
3	with parameters
4	unsigned int
5	returning
6	nothing
7
8	newExpr is Variable Expression: g: function
9	with parameters
10	unsigned int
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	unsigned int
32	returning
33	nothing
34
35	(types:
36	pointer to function
37	with parameters
38	unsigned int
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 a
64	decl is a: signed int
65	newExpr is Variable Expression: a: signed int
66
67	alternatives before prune:
68	Cost ( 0, 0, 0 ): Variable Expression: a: signed int
69	(types:
70	lvalue signed int
71	)
72	Environment:
73
74	there are 1 alternatives before elimination
75	there are 1 alternatives after elimination
76	alternatives before prune:
77	Cost ( 0, 0, 1 ): Cast of:
78	Variable Expression: a: signed int
79
80	to:
81	nothing
82	(types:
83	)
84	Environment:
85
86	there are 1 alternatives before elimination
87	there are 1 alternatives after elimination
88	nameExpr is b
89	decl is b: float
90	newExpr is Variable Expression: b: float
91
92	decl is b: signed int
93	newExpr is Variable Expression: b: signed int
94
95	alternatives before prune:
96	Cost ( 0, 0, 0 ): Variable Expression: b: float
97	(types:
98	lvalue float
99	)
100	Environment:
101
102	Cost ( 0, 0, 0 ): Variable Expression: b: signed int
103	(types:
104	lvalue signed int
105	)
106	Environment:
107
108	there are 2 alternatives before elimination
109	there are 2 alternatives after elimination
110	alternatives before prune:
111	Cost ( 0, 0, 0 ): Comma Expression:
112	Variable Expression: a: signed int
113
114	Variable Expression: b: signed int
115	(types:
116	lvalue signed int
117	)
118	Environment:
119
120	Cost ( 0, 0, 0 ): Comma Expression:
121	Variable Expression: a: signed int
122
123	Variable Expression: b: float
124	(types:
125	lvalue float
126	)
127	Environment:
128
129	there are 2 alternatives before elimination
130	there are 2 alternatives after elimination
131	findSubExprs
132	Cost ( 0, 0, 0 ): Comma Expression:
133	Variable Expression: a: signed int
134
135	Variable Expression: b: signed int
136	(types:
137	lvalue signed int
138	)
139	Environment:
140
141	Cost ( 0, 0, 0 ): Comma Expression:
142	Variable Expression: a: signed int
143
144	Variable Expression: b: float
145	(types:
146	lvalue float
147	)
148	Environment:
149
150	working on alternative:
151	Cost ( 0, 0, 0 ): Variable Expression: g: function
152	with parameters
153	signed int
154	returning
155	nothing
156
157	(types:
158	pointer to function
159	with parameters
160	signed int
161	returning
162	nothing
163
164	)
165	Environment:
166	formal type is signed int
167	actual type is lvalue signed int
168	need assertions:
169	============= original indexer
170	===idTable===
171	===typeTable===
172	===structTable===
173	===enumTable===
174	===unionTable===
175	===contextTable===
176	============= new indexer
177	===idTable===
178	===typeTable===
179	===structTable===
180	===enumTable===
181	===unionTable===
182	===contextTable===
183	formal type is signed int
184	actual type is lvalue float
185	need assertions:
186	============= original indexer
187	===idTable===
188	===typeTable===
189	===structTable===
190	===enumTable===
191	===unionTable===
192	===contextTable===
193	============= new indexer
194	===idTable===
195	===typeTable===
196	===structTable===
197	===enumTable===
198	===unionTable===
199	===contextTable===
200	working on alternative:
201	Cost ( 0, 0, 0 ): Variable Expression: g: function
202	with parameters
203	unsigned int
204	returning
205	nothing
206
207	(types:
208	pointer to function
209	with parameters
210	unsigned int
211	returning
212	nothing
213
214	)
215	Environment:
216	formal type is unsigned int
217	actual type is lvalue signed int
218	need assertions:
219	============= original indexer
220	===idTable===
221	===typeTable===
222	===structTable===
223	===enumTable===
224	===unionTable===
225	===contextTable===
226	============= new indexer
227	===idTable===
228	===typeTable===
229	===structTable===
230	===enumTable===
231	===unionTable===
232	===contextTable===
233	formal type is unsigned int
234	actual type is lvalue float
235	need assertions:
236	============= original indexer
237	===idTable===
238	===typeTable===
239	===structTable===
240	===enumTable===
241	===unionTable===
242	===contextTable===
243	============= new indexer
244	===idTable===
245	===typeTable===
246	===structTable===
247	===enumTable===
248	===unionTable===
249	===contextTable===
250	actual expression:
251	Comma Expression:
252	Variable Expression: a: signed int
253
254	Variable Expression: b: signed int
255	--- results are
256	lvalue signed int
257
258	converting lvalue signed int
259	to signed int
260	cost is( 0, 0, 0 )
261	Case +++++++++++++
262	formals are:
263	signed int
264	actuals are:
265	Comma Expression:
266	Variable Expression: a: signed int
267
268	Variable Expression: b: signed int
269
270	bindings are:
271	cost of conversion is:( 0, 0, 0 )
272	actual expression:
273	Comma Expression:
274	Variable Expression: a: signed int
275
276	Variable Expression: b: float
277	--- results are
278	lvalue float
279
280	converting lvalue float
281	to signed int
282	cost is( 1, 0, 0 )
283	Case +++++++++++++
284	formals are:
285	signed int
286	actuals are:
287	Cast of:
288	Comma Expression:
289	Variable Expression: a: signed int
290
291	Variable Expression: b: float
292
293	to:
294	signed int
295
296	bindings are:
297	cost of conversion is:( 1, 0, 0 )
298	actual expression:
299	Comma Expression:
300	Variable Expression: a: signed int
301
302	Variable Expression: b: signed int
303	--- results are
304	lvalue signed int
305
306	converting lvalue signed int
307	to unsigned int
308	cost is( 0, 0, 1 )
309	Case +++++++++++++
310	formals are:
311	unsigned int
312	actuals are:
313	Cast of:
314	Comma Expression:
315	Variable Expression: a: signed int
316
317	Variable Expression: b: signed int
318
319	to:
320	unsigned int
321
322	bindings are:
323	cost of conversion is:( 0, 0, 1 )
324	actual expression:
325	Comma Expression:
326	Variable Expression: a: signed int
327
328	Variable Expression: b: float
329	--- results are
330	lvalue float
331
332	converting lvalue float
333	to unsigned int
334	cost is( 1, 0, 0 )
335	Case +++++++++++++
336	formals are:
337	unsigned int
338	actuals are:
339	Cast of:
340	Comma Expression:
341	Variable Expression: a: signed int
342
343	Variable Expression: b: float
344
345	to:
346	unsigned int
347
348	bindings are:
349	cost of conversion is:( 1, 0, 0 )
350	alternatives before prune:
351	Cost ( 0, 0, 0 ): Application of
352	Variable Expression: g: function
353	with parameters
354	signed int
355	returning
356	nothing
357
358	to arguments
359	Comma Expression:
360	Variable Expression: a: signed int
361
362	Variable Expression: b: signed int
363
364	(types:
365	)
366	Environment:
367
368	Cost ( 1, 0, 0 ): Application of
369	Variable Expression: g: function
370	with parameters
371	signed int
372	returning
373	nothing
374
375	to arguments
376	Cast of:
377	Comma Expression:
378	Variable Expression: a: signed int
379
380	Variable Expression: b: float
381
382	to:
383	signed int
384
385	(types:
386	)
387	Environment:
388
389	Cost ( 0, 0, 1 ): Application of
390	Variable Expression: g: function
391	with parameters
392	unsigned int
393	returning
394	nothing
395
396	to arguments
397	Cast of:
398	Comma Expression:
399	Variable Expression: a: signed int
400
401	Variable Expression: b: signed int
402
403	to:
404	unsigned int
405
406	(types:
407	)
408	Environment:
409
410	Cost ( 1, 0, 0 ): Application of
411	Variable Expression: g: function
412	with parameters
413	unsigned int
414	returning
415	nothing
416
417	to arguments
418	Cast of:
419	Comma Expression:
420	Variable Expression: a: signed int
421
422	Variable Expression: b: float
423
424	to:
425	unsigned int
426
427	(types:
428	)
429	Environment:
430
431	there are 1 alternatives before elimination
432	there are 1 alternatives after elimination
433	alternatives before prune:
434	Cost ( 0, 0, 0 ): Cast of:
435	Application of
436	Variable Expression: g: function
437	with parameters
438	signed int
439	returning
440	nothing
441
442	to arguments
443	Comma Expression:
444	Variable Expression: a: signed int
445
446	Variable Expression: b: signed int
447
448
449	to:
450	nothing
451	(types:
452	)
453	Environment:
454
455	there are 1 alternatives before elimination
456	there are 1 alternatives after elimination
457	nameExpr is g
458	decl is g: function
459	with parameters
460	unsigned int
461	returning
462	nothing
463
464	newExpr is Variable Expression: g: function
465	with parameters
466	unsigned int
467	returning
468	nothing
469
470
471	decl is g: function
472	with parameters
473	signed int
474	returning
475	nothing
476
477	newExpr is Variable Expression: g: function
478	with parameters
479	signed int
480	returning
481	nothing
482
483
484	alternatives before prune:
485	Cost ( 0, 0, 0 ): Variable Expression: g: function
486	with parameters
487	unsigned int
488	returning
489	nothing
490
491	(types:
492	pointer to function
493	with parameters
494	unsigned int
495	returning
496	nothing
497
498	)
499	Environment:
500
501	Cost ( 0, 0, 0 ): Variable Expression: g: function
502	with parameters
503	signed int
504	returning
505	nothing
506
507	(types:
508	pointer to function
509	with parameters
510	signed int
511	returning
512	nothing
513
514	)
515	Environment:
516
517	there are 2 alternatives before elimination
518	there are 2 alternatives after elimination
519	nameExpr is a
520	decl is a: signed int
521	newExpr is Variable Expression: a: signed int
522
523	alternatives before prune:
524	Cost ( 0, 0, 0 ): Variable Expression: a: signed int
525	(types:
526	lvalue signed int
527	)
528	Environment:
529
530	there are 1 alternatives before elimination
531	there are 1 alternatives after elimination
532	alternatives before prune:
533	Cost ( 0, 0, 1 ): Cast of:
534	Variable Expression: a: signed int
535
536	to:
537	nothing
538	(types:
539	)
540	Environment:
541
542	there are 1 alternatives before elimination
543	there are 1 alternatives after elimination
544	nameExpr is a
545	decl is a: signed int
546	newExpr is Variable Expression: a: signed int
547
548	alternatives before prune:
549	Cost ( 0, 0, 0 ): Variable Expression: a: signed int
550	(types:
551	lvalue signed int
552	)
553	Environment:
554
555	there are 1 alternatives before elimination
556	there are 1 alternatives after elimination
557	alternatives before prune:
558	Cost ( 0, 0, 0 ): Comma Expression:
559	Variable Expression: a: signed int
560
561	Variable Expression: a: signed int
562	(types:
563	lvalue signed int
564	)
565	Environment:
566
567	there are 1 alternatives before elimination
568	there are 1 alternatives after elimination
569	alternatives before prune:
570	Cost ( 0, 0, 1 ): Cast of:
571	Comma Expression:
572	Variable Expression: a: signed int
573
574	Variable Expression: a: signed int
575
576	to:
577	nothing
578	(types:
579	)
580	Environment:
581
582	there are 1 alternatives before elimination
583	there are 1 alternatives after elimination
584	nameExpr is b
585	decl is b: float
586	newExpr is Variable Expression: b: float
587
588	decl is b: signed int
589	newExpr is Variable Expression: b: signed int
590
591	alternatives before prune:
592	Cost ( 0, 0, 0 ): Variable Expression: b: float
593	(types:
594	lvalue float
595	)
596	Environment:
597
598	Cost ( 0, 0, 0 ): Variable Expression: b: signed int
599	(types:
600	lvalue signed int
601	)
602	Environment:
603
604	there are 2 alternatives before elimination
605	there are 2 alternatives after elimination
606	alternatives before prune:
607	Cost ( 0, 0, 0 ): Comma Expression:
608	Comma Expression:
609	Variable Expression: a: signed int
610
611	Variable Expression: a: signed int
612
613	Variable Expression: b: signed int
614	(types:
615	lvalue signed int
616	)
617	Environment:
618
619	Cost ( 0, 0, 0 ): Comma Expression:
620	Comma Expression:
621	Variable Expression: a: signed int
622
623	Variable Expression: a: signed int
624
625	Variable Expression: b: float
626	(types:
627	lvalue float
628	)
629	Environment:
630
631	there are 2 alternatives before elimination
632	there are 2 alternatives after elimination
633	findSubExprs
634	Cost ( 0, 0, 0 ): Comma Expression:
635	Comma Expression:
636	Variable Expression: a: signed int
637
638	Variable Expression: a: signed int
639
640	Variable Expression: b: signed int
641	(types:
642	lvalue signed int
643	)
644	Environment:
645
646	Cost ( 0, 0, 0 ): Comma Expression:
647	Comma Expression:
648	Variable Expression: a: signed int
649
650	Variable Expression: a: signed int
651
652	Variable Expression: b: float
653	(types:
654	lvalue float
655	)
656	Environment:
657
658	working on alternative:
659	Cost ( 0, 0, 0 ): Variable Expression: g: function
660	with parameters
661	signed int
662	returning
663	nothing
664
665	(types:
666	pointer to function
667	with parameters
668	signed int
669	returning
670	nothing
671
672	)
673	Environment:
674	formal type is signed int
675	actual type is lvalue signed int
676	need assertions:
677	============= original indexer
678	===idTable===
679	===typeTable===
680	===structTable===
681	===enumTable===
682	===unionTable===
683	===contextTable===
684	============= new indexer
685	===idTable===
686	===typeTable===
687	===structTable===
688	===enumTable===
689	===unionTable===
690	===contextTable===
691	formal type is signed int
692	actual type is lvalue float
693	need assertions:
694	============= original indexer
695	===idTable===
696	===typeTable===
697	===structTable===
698	===enumTable===
699	===unionTable===
700	===contextTable===
701	============= new indexer
702	===idTable===
703	===typeTable===
704	===structTable===
705	===enumTable===
706	===unionTable===
707	===contextTable===
708	working on alternative:
709	Cost ( 0, 0, 0 ): Variable Expression: g: function
710	with parameters
711	unsigned int
712	returning
713	nothing
714
715	(types:
716	pointer to function
717	with parameters
718	unsigned int
719	returning
720	nothing
721
722	)
723	Environment:
724	formal type is unsigned int
725	actual type is lvalue signed int
726	need assertions:
727	============= original indexer
728	===idTable===
729	===typeTable===
730	===structTable===
731	===enumTable===
732	===unionTable===
733	===contextTable===
734	============= new indexer
735	===idTable===
736	===typeTable===
737	===structTable===
738	===enumTable===
739	===unionTable===
740	===contextTable===
741	formal type is unsigned int
742	actual type is lvalue float
743	need assertions:
744	============= original indexer
745	===idTable===
746	===typeTable===
747	===structTable===
748	===enumTable===
749	===unionTable===
750	===contextTable===
751	============= new indexer
752	===idTable===
753	===typeTable===
754	===structTable===
755	===enumTable===
756	===unionTable===
757	===contextTable===
758	actual expression:
759	Comma Expression:
760	Comma Expression:
761	Variable Expression: a: signed int
762
763	Variable Expression: a: signed int
764
765	Variable Expression: b: signed int
766	--- results are
767	lvalue signed int
768
769	converting lvalue signed int
770	to signed int
771	cost is( 0, 0, 0 )
772	Case +++++++++++++
773	formals are:
774	signed int
775	actuals are:
776	Comma Expression:
777	Comma Expression:
778	Variable Expression: a: signed int
779
780	Variable Expression: a: signed int
781
782	Variable Expression: b: signed int
783
784	bindings are:
785	cost of conversion is:( 0, 0, 0 )
786	actual expression:
787	Comma Expression:
788	Comma Expression:
789	Variable Expression: a: signed int
790
791	Variable Expression: a: signed int
792
793	Variable Expression: b: float
794	--- results are
795	lvalue float
796
797	converting lvalue float
798	to signed int
799	cost is( 1, 0, 0 )
800	Case +++++++++++++
801	formals are:
802	signed int
803	actuals are:
804	Cast of:
805	Comma Expression:
806	Comma Expression:
807	Variable Expression: a: signed int
808
809	Variable Expression: a: signed int
810
811	Variable Expression: b: float
812
813	to:
814	signed int
815
816	bindings are:
817	cost of conversion is:( 1, 0, 0 )
818	actual expression:
819	Comma Expression:
820	Comma Expression:
821	Variable Expression: a: signed int
822
823	Variable Expression: a: signed int
824
825	Variable Expression: b: signed int
826	--- results are
827	lvalue signed int
828
829	converting lvalue signed int
830	to unsigned int
831	cost is( 0, 0, 1 )
832	Case +++++++++++++
833	formals are:
834	unsigned int
835	actuals are:
836	Cast of:
837	Comma Expression:
838	Comma Expression:
839	Variable Expression: a: signed int
840
841	Variable Expression: a: signed int
842
843	Variable Expression: b: signed int
844
845	to:
846	unsigned int
847
848	bindings are:
849	cost of conversion is:( 0, 0, 1 )
850	actual expression:
851	Comma Expression:
852	Comma Expression:
853	Variable Expression: a: signed int
854
855	Variable Expression: a: signed int
856
857	Variable Expression: b: float
858	--- results are
859	lvalue float
860
861	converting lvalue float
862	to unsigned int
863	cost is( 1, 0, 0 )
864	Case +++++++++++++
865	formals are:
866	unsigned int
867	actuals are:
868	Cast of:
869	Comma Expression:
870	Comma Expression:
871	Variable Expression: a: signed int
872
873	Variable Expression: a: signed int
874
875	Variable Expression: b: float
876
877	to:
878	unsigned int
879
880	bindings are:
881	cost of conversion is:( 1, 0, 0 )
882	alternatives before prune:
883	Cost ( 0, 0, 0 ): Application of
884	Variable Expression: g: function
885	with parameters
886	signed int
887	returning
888	nothing
889
890	to arguments
891	Comma Expression:
892	Comma Expression:
893	Variable Expression: a: signed int
894
895	Variable Expression: a: signed int
896
897	Variable Expression: b: signed int
898
899	(types:
900	)
901	Environment:
902
903	Cost ( 1, 0, 0 ): Application of
904	Variable Expression: g: function
905	with parameters
906	signed int
907	returning
908	nothing
909
910	to arguments
911	Cast of:
912	Comma Expression:
913	Comma Expression:
914	Variable Expression: a: signed int
915
916	Variable Expression: a: signed int
917
918	Variable Expression: b: float
919
920	to:
921	signed int
922
923	(types:
924	)
925	Environment:
926
927	Cost ( 0, 0, 1 ): Application of
928	Variable Expression: g: function
929	with parameters
930	unsigned int
931	returning
932	nothing
933
934	to arguments
935	Cast of:
936	Comma Expression:
937	Comma Expression:
938	Variable Expression: a: signed int
939
940	Variable Expression: a: signed int
941
942	Variable Expression: b: signed int
943
944	to:
945	unsigned int
946
947	(types:
948	)
949	Environment:
950
951	Cost ( 1, 0, 0 ): Application of
952	Variable Expression: g: function
953	with parameters
954	unsigned int
955	returning
956	nothing
957
958	to arguments
959	Cast of:
960	Comma Expression:
961	Comma Expression:
962	Variable Expression: a: signed int
963
964	Variable Expression: a: signed int
965
966	Variable Expression: b: float
967
968	to:
969	unsigned int
970
971	(types:
972	)
973	Environment:
974
975	there are 1 alternatives before elimination
976	there are 1 alternatives after elimination
977	alternatives before prune:
978	Cost ( 0, 0, 0 ): Cast of:
979	Application of
980	Variable Expression: g: function
981	with parameters
982	signed int
983	returning
984	nothing
985
986	to arguments
987	Comma Expression:
988	Comma Expression:
989	Variable Expression: a: signed int
990
991	Variable Expression: a: signed int
992
993	Variable Expression: b: signed int
994
995
996	to:
997	nothing
998	(types:
999	)
1000	Environment:
1001
1002	there are 1 alternatives before elimination
1003	there are 1 alternatives after elimination
1004	nameExpr is g
1005	decl is g: function
1006	with parameters
1007	unsigned int
1008	returning
1009	nothing
1010
1011	newExpr is Variable Expression: g: function
1012	with parameters
1013	unsigned int
1014	returning
1015	nothing
1016
1017
1018	decl is g: function
1019	with parameters
1020	signed int
1021	returning
1022	nothing
1023
1024	newExpr is Variable Expression: g: function
1025	with parameters
1026	signed int
1027	returning
1028	nothing
1029
1030
1031	alternatives before prune:
1032	Cost ( 0, 0, 0 ): Variable Expression: g: function
1033	with parameters
1034	unsigned int
1035	returning
1036	nothing
1037
1038	(types:
1039	pointer to function
1040	with parameters
1041	unsigned int
1042	returning
1043	nothing
1044
1045	)
1046	Environment:
1047
1048	Cost ( 0, 0, 0 ): Variable Expression: g: function
1049	with parameters
1050	signed int
1051	returning
1052	nothing
1053
1054	(types:
1055	pointer to function
1056	with parameters
1057	signed int
1058	returning
1059	nothing
1060
1061	)
1062	Environment:
1063
1064	there are 2 alternatives before elimination
1065	there are 2 alternatives after elimination
1066	nameExpr is a
1067	decl is a: signed int
1068	newExpr is Variable Expression: a: signed int
1069
1070	alternatives before prune:
1071	Cost ( 0, 0, 0 ): Variable Expression: a: signed int
1072	(types:
1073	lvalue signed int
1074	)
1075	Environment:
1076
1077	there are 1 alternatives before elimination
1078	there are 1 alternatives after elimination
1079	alternatives before prune:
1080	Cost ( 0, 0, 0 ): Sizeof Expression on: Variable Expression: a: signed int
1081
1082	(types:
1083	unsigned int
1084	)
1085	Environment:
1086
1087	there are 1 alternatives before elimination
1088	there are 1 alternatives after elimination
1089	findSubExprs
1090	Cost ( 0, 0, 0 ): Sizeof Expression on: Variable Expression: a: signed int
1091
1092	(types:
1093	unsigned int
1094	)
1095	Environment:
1096
1097	working on alternative:
1098	Cost ( 0, 0, 0 ): Variable Expression: g: function
1099	with parameters
1100	signed int
1101	returning
1102	nothing
1103
1104	(types:
1105	pointer to function
1106	with parameters
1107	signed int
1108	returning
1109	nothing
1110
1111	)
1112	Environment:
1113	formal type is signed int
1114	actual type is unsigned int
1115	need assertions:
1116	============= original indexer
1117	===idTable===
1118	===typeTable===
1119	===structTable===
1120	===enumTable===
1121	===unionTable===
1122	===contextTable===
1123	============= new indexer
1124	===idTable===
1125	===typeTable===
1126	===structTable===
1127	===enumTable===
1128	===unionTable===
1129	===contextTable===
1130	working on alternative:
1131	Cost ( 0, 0, 0 ): Variable Expression: g: function
1132	with parameters
1133	unsigned int
1134	returning
1135	nothing
1136
1137	(types:
1138	pointer to function
1139	with parameters
1140	unsigned int
1141	returning
1142	nothing
1143
1144	)
1145	Environment:
1146	formal type is unsigned int
1147	actual type is unsigned int
1148	need assertions:
1149	============= original indexer
1150	===idTable===
1151	===typeTable===
1152	===structTable===
1153	===enumTable===
1154	===unionTable===
1155	===contextTable===
1156	============= new indexer
1157	===idTable===
1158	===typeTable===
1159	===structTable===
1160	===enumTable===
1161	===unionTable===
1162	===contextTable===
1163	actual expression:
1164	Sizeof Expression on: Variable Expression: a: signed int
1165
1166	--- results are
1167	unsigned int
1168
1169	converting unsigned int
1170	to signed int
1171	cost is( 1, 0, 0 )
1172	Case +++++++++++++
1173	formals are:
1174	signed int
1175	actuals are:
1176	Cast of:
1177	Sizeof Expression on: Variable Expression: a: signed int
1178
1179
1180	to:
1181	signed int
1182
1183	bindings are:
1184	cost of conversion is:( 1, 0, 0 )
1185	actual expression:
1186	Sizeof Expression on: Variable Expression: a: signed int
1187
1188	--- results are
1189	unsigned int
1190
1191	converting unsigned int
1192	to unsigned int
1193	cost is( 0, 0, 0 )
1194	Case +++++++++++++
1195	formals are:
1196	unsigned int
1197	actuals are:
1198	Sizeof Expression on: Variable Expression: a: signed int
1199
1200
1201	bindings are:
1202	cost of conversion is:( 0, 0, 0 )
1203	alternatives before prune:
1204	Cost ( 1, 0, 0 ): Application of
1205	Variable Expression: g: function
1206	with parameters
1207	signed int
1208	returning
1209	nothing
1210
1211	to arguments
1212	Cast of:
1213	Sizeof Expression on: Variable Expression: a: signed int
1214
1215
1216	to:
1217	signed int
1218
1219	(types:
1220	)
1221	Environment:
1222
1223	Cost ( 0, 0, 0 ): Application of
1224	Variable Expression: g: function
1225	with parameters
1226	unsigned int
1227	returning
1228	nothing
1229
1230	to arguments
1231	Sizeof Expression on: Variable Expression: a: signed int
1232
1233
1234	(types:
1235	)
1236	Environment:
1237
1238	cost ( 0, 0, 0 ) beats ( 1, 0, 0 )
1239	there are 1 alternatives before elimination
1240	there are 1 alternatives after elimination
1241	alternatives before prune:
1242	Cost ( 0, 0, 0 ): Cast of:
1243	Application of
1244	Variable Expression: g: function
1245	with parameters
1246	unsigned int
1247	returning
1248	nothing
1249
1250	to arguments
1251	Sizeof Expression on: Variable Expression: a: signed int
1252
1253
1254
1255	to:
1256	nothing
1257	(types:
1258	)
1259	Environment:
1260
1261	there are 1 alternatives before elimination
1262	there are 1 alternatives after elimination
1263	nameExpr is g
1264	decl is g: function
1265	with parameters
1266	unsigned int
1267	returning
1268	nothing
1269
1270	newExpr is Variable Expression: g: function
1271	with parameters
1272	unsigned int
1273	returning
1274	nothing
1275
1276
1277	decl is g: function
1278	with parameters
1279	signed int
1280	returning
1281	nothing
1282
1283	newExpr is Variable Expression: g: function
1284	with parameters
1285	signed int
1286	returning
1287	nothing
1288
1289
1290	alternatives before prune:
1291	Cost ( 0, 0, 0 ): Variable Expression: g: function
1292	with parameters
1293	unsigned int
1294	returning
1295	nothing
1296
1297	(types:
1298	pointer to function
1299	with parameters
1300	unsigned int
1301	returning
1302	nothing
1303
1304	)
1305	Environment:
1306
1307	Cost ( 0, 0, 0 ): Variable Expression: g: function
1308	with parameters
1309	signed int
1310	returning
1311	nothing
1312
1313	(types:
1314	pointer to function
1315	with parameters
1316	signed int
1317	returning
1318	nothing
1319
1320	)
1321	Environment:
1322
1323	there are 2 alternatives before elimination
1324	there are 2 alternatives after elimination
1325	alternatives before prune:
1326	Cost ( 0, 0, 0 ): Sizeof Expression on: signed int
1327	(types:
1328	unsigned int
1329	)
1330	Environment:
1331
1332	there are 1 alternatives before elimination
1333	there are 1 alternatives after elimination
1334	findSubExprs
1335	Cost ( 0, 0, 0 ): Sizeof Expression on: signed int
1336	(types:
1337	unsigned int
1338	)
1339	Environment:
1340
1341	working on alternative:
1342	Cost ( 0, 0, 0 ): Variable Expression: g: function
1343	with parameters
1344	signed int
1345	returning
1346	nothing
1347
1348	(types:
1349	pointer to function
1350	with parameters
1351	signed int
1352	returning
1353	nothing
1354
1355	)
1356	Environment:
1357	formal type is signed int
1358	actual type is unsigned int
1359	need assertions:
1360	============= original indexer
1361	===idTable===
1362	===typeTable===
1363	===structTable===
1364	===enumTable===
1365	===unionTable===
1366	===contextTable===
1367	============= new indexer
1368	===idTable===
1369	===typeTable===
1370	===structTable===
1371	===enumTable===
1372	===unionTable===
1373	===contextTable===
1374	working on alternative:
1375	Cost ( 0, 0, 0 ): Variable Expression: g: function
1376	with parameters
1377	unsigned int
1378	returning
1379	nothing
1380
1381	(types:
1382	pointer to function
1383	with parameters
1384	unsigned int
1385	returning
1386	nothing
1387
1388	)
1389	Environment:
1390	formal type is unsigned int
1391	actual type is unsigned int
1392	need assertions:
1393	============= original indexer
1394	===idTable===
1395	===typeTable===
1396	===structTable===
1397	===enumTable===
1398	===unionTable===
1399	===contextTable===
1400	============= new indexer
1401	===idTable===
1402	===typeTable===
1403	===structTable===
1404	===enumTable===
1405	===unionTable===
1406	===contextTable===
1407	actual expression:
1408	Sizeof Expression on: signed int
1409	--- results are
1410	unsigned int
1411
1412	converting unsigned int
1413	to signed int
1414	cost is( 1, 0, 0 )
1415	Case +++++++++++++
1416	formals are:
1417	signed int
1418	actuals are:
1419	Cast of:
1420	Sizeof Expression on: signed int
1421
1422	to:
1423	signed int
1424
1425	bindings are:
1426	cost of conversion is:( 1, 0, 0 )
1427	actual expression:
1428	Sizeof Expression on: signed int
1429	--- results are
1430	unsigned int
1431
1432	converting unsigned int
1433	to unsigned int
1434	cost is( 0, 0, 0 )
1435	Case +++++++++++++
1436	formals are:
1437	unsigned int
1438	actuals are:
1439	Sizeof Expression on: signed int
1440
1441	bindings are:
1442	cost of conversion is:( 0, 0, 0 )
1443	alternatives before prune:
1444	Cost ( 1, 0, 0 ): Application of
1445	Variable Expression: g: function
1446	with parameters
1447	signed int
1448	returning
1449	nothing
1450
1451	to arguments
1452	Cast of:
1453	Sizeof Expression on: signed int
1454
1455	to:
1456	signed int
1457
1458	(types:
1459	)
1460	Environment:
1461
1462	Cost ( 0, 0, 0 ): Application of
1463	Variable Expression: g: function
1464	with parameters
1465	unsigned int
1466	returning
1467	nothing
1468
1469	to arguments
1470	Sizeof Expression on: signed int
1471
1472	(types:
1473	)
1474	Environment:
1475
1476	cost ( 0, 0, 0 ) beats ( 1, 0, 0 )
1477	there are 1 alternatives before elimination
1478	there are 1 alternatives after elimination
1479	alternatives before prune:
1480	Cost ( 0, 0, 0 ): Cast of:
1481	Application of
1482	Variable Expression: g: function
1483	with parameters
1484	unsigned int
1485	returning
1486	nothing
1487
1488	to arguments
1489	Sizeof Expression on: signed int
1490
1491
1492	to:
1493	nothing
1494	(types:
1495	)
1496	Environment:
1497
1498	there are 1 alternatives before elimination
1499	there are 1 alternatives after elimination
1500	int __a__i;
1501	int __b__i;
1502	float __b__f;
1503	void __g__F_i_(int );
1504	void __g__F_Ui_(unsigned int );
1505	void __f__F__(void){
1506	__g__F_i_((__a__i , __b__i));
1507	__g__F_i_(((__a__i , __a__i) , __b__i));
1508	__g__F_Ui_(sizeof(__a__i));
1509	__g__F_Ui_(sizeof(int ));
1510	}

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

Download in other formats: