Context Navigation

source: src/Tests/Expect-r/Operators.txt @ d67a9a1

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 d67a9a1 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: 38.1 KB

Line
1	nameExpr is ?*?
2	decl is ?*?: function
3	with parameters
4	signed int
5	signed int
6	returning
7	signed int
8
9	newExpr is Variable Expression: ?*?: function
10	with parameters
11	signed int
12	signed int
13	returning
14	signed int
15
16
17	alternatives before prune:
18	Cost ( 0, 0, 0 ): Variable Expression: ?*?: function
19	with parameters
20	signed int
21	signed int
22	returning
23	signed int
24
25	(types:
26	pointer to function
27	with parameters
28	signed int
29	signed int
30	returning
31	signed int
32
33	)
34	Environment:
35
36	there are 1 alternatives before elimination
37	there are 1 alternatives after elimination
38	nameExpr is number1
39	decl is number1: signed int
40	newExpr is Variable Expression: number1: signed int
41
42	alternatives before prune:
43	Cost ( 0, 0, 0 ): Variable Expression: number1: signed int
44	(types:
45	lvalue signed int
46	)
47	Environment:
48
49	there are 1 alternatives before elimination
50	there are 1 alternatives after elimination
51	findSubExprs
52	Cost ( 0, 0, 0 ): Variable Expression: number1: signed int
53	(types:
54	lvalue signed int
55	)
56	Environment:
57
58	nameExpr is number2
59	decl is number2: signed int
60	newExpr is Variable Expression: number2: signed int
61
62	alternatives before prune:
63	Cost ( 0, 0, 0 ): Variable Expression: number2: signed int
64	(types:
65	lvalue signed int
66	)
67	Environment:
68
69	there are 1 alternatives before elimination
70	there are 1 alternatives after elimination
71	findSubExprs
72	Cost ( 0, 0, 0 ): Variable Expression: number2: signed int
73	(types:
74	lvalue signed int
75	)
76	Environment:
77
78	working on alternative:
79	Cost ( 0, 0, 0 ): Variable Expression: ?*?: function
80	with parameters
81	signed int
82	signed int
83	returning
84	signed int
85
86	(types:
87	pointer to function
88	with parameters
89	signed int
90	signed int
91	returning
92	signed int
93
94	)
95	Environment:
96	formal type is signed int
97	actual type is lvalue signed int
98	formal type is signed int
99	actual type is lvalue signed int
100	need assertions:
101	============= original indexer
102	===idTable===
103	===typeTable===
104	===structTable===
105	===enumTable===
106	===unionTable===
107	===contextTable===
108	============= new indexer
109	===idTable===
110	===typeTable===
111	===structTable===
112	===enumTable===
113	===unionTable===
114	===contextTable===
115	actual expression:
116	Variable Expression: number1: signed int
117	--- results are
118	lvalue signed int
119
120	converting lvalue signed int
121	to signed int
122	cost is( 0, 0, 0 )
123	actual expression:
124	Variable Expression: number2: signed int
125	--- results are
126	lvalue signed int
127
128	converting lvalue signed int
129	to signed int
130	cost is( 0, 0, 0 )
131	Case +++++++++++++
132	formals are:
133	signed int
134	signed int
135	actuals are:
136	Variable Expression: number1: signed int
137
138	Variable Expression: number2: signed int
139
140	bindings are:
141	cost of conversion is:( 0, 0, 0 )
142	alternatives before prune:
143	Cost ( 0, 0, 0 ): Application of
144	Variable Expression: ?*?: function
145	with parameters
146	signed int
147	signed int
148	returning
149	signed int
150
151	to arguments
152	Variable Expression: number1: signed int
153
154	Variable Expression: number2: signed int
155
156	(types:
157	signed int
158	)
159	Environment:
160
161	there are 1 alternatives before elimination
162	there are 1 alternatives after elimination
163	alternatives before prune:
164	Cost ( 0, 0, 0 ): Cast of:
165	Application of
166	Variable Expression: ?*?: function
167	with parameters
168	signed int
169	signed int
170	returning
171	signed int
172
173	to arguments
174	Variable Expression: number1: signed int
175
176	Variable Expression: number2: signed int
177
178
179	to:
180	signed int
181	(types:
182	signed int
183	)
184	Environment:
185
186	there are 1 alternatives before elimination
187	there are 1 alternatives after elimination
188	nameExpr is ?=?
189	decl is ?=?: automatically generated inline static function
190	with parameters
191	_dst: pointer to instance of struct accumulator
192	_src: instance of struct accumulator
193	returning
194	instance of struct accumulator
195	with body
196	CompoundStmt
197	Expression Statement:
198	Applying untyped:
199	Name: ?=?
200	...to:
201	Address of:
202	Member Expression, with field:
203	total: signed int
204	from aggregate:
205	Applying untyped:
206	Name: *?
207	...to:
208	Variable Expression: _dst: pointer to instance of struct accumulator
209	Member Expression, with field:
210	total: signed int
211	from aggregate:
212	Variable Expression: _src: instance of struct accumulator
213
214	Return Statement, returning: Variable Expression: _src: instance of struct accumulator
215
216
217
218	newExpr is Variable Expression: ?=?: inline static function
219	with parameters
220	_dst: pointer to instance of struct accumulator
221	_src: instance of struct accumulator
222	returning
223	instance of struct accumulator
224
225
226	decl is ?=?: function
227	with parameters
228	pointer to signed int
229	signed int
230	returning
231	signed int
232
233	newExpr is Variable Expression: ?=?: function
234	with parameters
235	pointer to signed int
236	signed int
237	returning
238	signed int
239
240
241	alternatives before prune:
242	Cost ( 0, 0, 0 ): Variable Expression: ?=?: inline static function
243	with parameters
244	_dst: pointer to instance of struct accumulator
245	_src: instance of struct accumulator
246	returning
247	instance of struct accumulator
248
249	(types:
250	pointer to function
251	with parameters
252	_dst: pointer to instance of struct accumulator
253	_src: instance of struct accumulator
254	returning
255	instance of struct accumulator
256
257	)
258	Environment:
259
260	Cost ( 0, 0, 0 ): Variable Expression: ?=?: function
261	with parameters
262	pointer to signed int
263	signed int
264	returning
265	signed int
266
267	(types:
268	pointer to function
269	with parameters
270	pointer to signed int
271	signed int
272	returning
273	signed int
274
275	)
276	Environment:
277
278	there are 2 alternatives before elimination
279	there are 2 alternatives after elimination
280	alternatives before prune:
281	Cost ( 0, 0, 0 ): Member Expression, with field:
282	total: signed int
283	from aggregate:
284	Applying untyped:
285	Name: *?
286	...to:
287	Variable Expression: _dst: pointer to instance of struct accumulator
288	(types:
289	lvalue signed int
290	)
291	Environment:
292
293	there are 1 alternatives before elimination
294	there are 1 alternatives after elimination
295	alternatives before prune:
296	Cost ( 0, 0, 0 ): Address of:
297	Member Expression, with field:
298	total: signed int
299	from aggregate:
300	Applying untyped:
301	Name: *?
302	...to:
303	Variable Expression: _dst: pointer to instance of struct accumulator
304	(types:
305	pointer to signed int
306	)
307	Environment:
308
309	there are 1 alternatives before elimination
310	there are 1 alternatives after elimination
311	findSubExprs
312	Cost ( 0, 0, 0 ): Address of:
313	Member Expression, with field:
314	total: signed int
315	from aggregate:
316	Applying untyped:
317	Name: *?
318	...to:
319	Variable Expression: _dst: pointer to instance of struct accumulator
320	(types:
321	pointer to signed int
322	)
323	Environment:
324
325	alternatives before prune:
326	Cost ( 0, 0, 0 ): Member Expression, with field:
327	total: signed int
328	from aggregate:
329	Variable Expression: _src: instance of struct accumulator
330	(types:
331	lvalue signed int
332	)
333	Environment:
334
335	there are 1 alternatives before elimination
336	there are 1 alternatives after elimination
337	findSubExprs
338	Cost ( 0, 0, 0 ): Member Expression, with field:
339	total: signed int
340	from aggregate:
341	Variable Expression: _src: instance of struct accumulator
342	(types:
343	lvalue signed int
344	)
345	Environment:
346
347	working on alternative:
348	Cost ( 0, 0, 0 ): Variable Expression: ?=?: function
349	with parameters
350	pointer to signed int
351	signed int
352	returning
353	signed int
354
355	(types:
356	pointer to function
357	with parameters
358	pointer to signed int
359	signed int
360	returning
361	signed int
362
363	)
364	Environment:
365	formal type is pointer to signed int
366	actual type is pointer to signed int
367	formal type is signed int
368	actual type is lvalue signed int
369	need assertions:
370	============= original indexer
371	===idTable===
372	===typeTable===
373	===structTable===
374	===enumTable===
375	===unionTable===
376	===contextTable===
377	============= new indexer
378	===idTable===
379	===typeTable===
380	===structTable===
381	===enumTable===
382	===unionTable===
383	===contextTable===
384	working on alternative:
385	Cost ( 0, 0, 0 ): Variable Expression: ?=?: inline static function
386	with parameters
387	_dst: pointer to instance of struct accumulator
388	_src: instance of struct accumulator
389	returning
390	instance of struct accumulator
391
392	(types:
393	pointer to function
394	with parameters
395	_dst: pointer to instance of struct accumulator
396	_src: instance of struct accumulator
397	returning
398	instance of struct accumulator
399
400	)
401	Environment:
402	formal type is pointer to instance of struct accumulator
403	actual type is pointer to signed int
404	actual expression:
405	Address of:
406	Member Expression, with field:
407	total: signed int
408	from aggregate:
409	Applying untyped:
410	Name: *?
411	...to:
412	Variable Expression: _dst: pointer to instance of struct accumulator
413	--- results are
414	pointer to signed int
415
416	converting pointer to signed int
417	to pointer to signed int
418	cost is( 0, 0, 0 )
419	actual expression:
420	Member Expression, with field:
421	total: signed int
422	from aggregate:
423	Variable Expression: _src: instance of struct accumulator
424	--- results are
425	lvalue signed int
426
427	converting lvalue signed int
428	to signed int
429	cost is( 0, 0, 0 )
430	Case +++++++++++++
431	formals are:
432	pointer to signed int
433	signed int
434	actuals are:
435	Address of:
436	Member Expression, with field:
437	total: signed int
438	from aggregate:
439	Applying untyped:
440	Name: *?
441	...to:
442	Variable Expression: _dst: pointer to instance of struct accumulator
443
444	Member Expression, with field:
445	total: signed int
446	from aggregate:
447	Variable Expression: _src: instance of struct accumulator
448
449	bindings are:
450	cost of conversion is:( 0, 0, 0 )
451	alternatives before prune:
452	Cost ( 0, 0, 0 ): Application of
453	Variable Expression: ?=?: function
454	with parameters
455	pointer to signed int
456	signed int
457	returning
458	signed int
459
460	to arguments
461	Address of:
462	Member Expression, with field:
463	total: signed int
464	from aggregate:
465	Applying untyped:
466	Name: *?
467	...to:
468	Variable Expression: _dst: pointer to instance of struct accumulator
469
470	Member Expression, with field:
471	total: signed int
472	from aggregate:
473	Variable Expression: _src: instance of struct accumulator
474
475	(types:
476	signed int
477	)
478	Environment:
479
480	there are 1 alternatives before elimination
481	there are 1 alternatives after elimination
482	alternatives before prune:
483	Cost ( 0, 0, 1 ): Cast of:
484	Application of
485	Variable Expression: ?=?: function
486	with parameters
487	pointer to signed int
488	signed int
489	returning
490	signed int
491
492	to arguments
493	Address of:
494	Member Expression, with field:
495	total: signed int
496	from aggregate:
497	Applying untyped:
498	Name: *?
499	...to:
500	Variable Expression: _dst: pointer to instance of struct accumulator
501
502	Member Expression, with field:
503	total: signed int
504	from aggregate:
505	Variable Expression: _src: instance of struct accumulator
506
507
508	to:
509	nothing
510	(types:
511	)
512	Environment:
513
514	there are 1 alternatives before elimination
515	there are 1 alternatives after elimination
516	alternatives before prune:
517	Cost ( 0, 0, 0 ): Variable Expression: _src: instance of struct accumulator
518	(types:
519	lvalue instance of struct accumulator
520	)
521	Environment:
522
523	there are 1 alternatives before elimination
524	there are 1 alternatives after elimination
525	alternatives before prune:
526	Cost ( 0, 0, 0 ): Cast of:
527	Variable Expression: _src: instance of struct accumulator
528
529	to:
530	instance of struct accumulator
531	(types:
532	instance of struct accumulator
533	)
534	Environment:
535
536	there are 1 alternatives before elimination
537	there are 1 alternatives after elimination
538	nameExpr is ?()
539	decl is ?(): function
540	with parameters
541	a: instance of struct accumulator
542	number1: char
543	number2: char
544	returning
545	char
546
547	newExpr is Variable Expression: ?(): function
548	with parameters
549	a: instance of struct accumulator
550	number1: char
551	number2: char
552	returning
553	char
554
555
556	decl is ?(): function
557	with parameters
558	number1: signed int
559	number2: signed int
560	returning
561	signed int
562	with body
563	CompoundStmt
564	Return Statement, returning: Cast of:
565	Application of
566	Variable Expression: ?*?: function
567	with parameters
568	signed int
569	signed int
570	returning
571	signed int
572
573	to arguments
574	Variable Expression: number1: signed int
575
576	Variable Expression: number2: signed int
577
578
579	to:
580	signed int
581	with environment:
582	Types:
583	Non-types:
584
585
586
587	newExpr is Variable Expression: ?(): function
588	with parameters
589	number1: signed int
590	number2: signed int
591	returning
592	signed int
593
594
595	alternatives before prune:
596	Cost ( 0, 0, 0 ): Variable Expression: ?(): function
597	with parameters
598	a: instance of struct accumulator
599	number1: char
600	number2: char
601	returning
602	char
603
604	(types:
605	pointer to function
606	with parameters
607	a: instance of struct accumulator
608	number1: char
609	number2: char
610	returning
611	char
612
613	)
614	Environment:
615
616	Cost ( 0, 0, 0 ): Variable Expression: ?(): function
617	with parameters
618	number1: signed int
619	number2: signed int
620	returning
621	signed int
622
623	(types:
624	pointer to function
625	with parameters
626	number1: signed int
627	number2: signed int
628	returning
629	signed int
630
631	)
632	Environment:
633
634	there are 2 alternatives before elimination
635	there are 2 alternatives after elimination
636	nameExpr is a
637	decl is a: char
638	newExpr is Variable Expression: a: char
639
640	alternatives before prune:
641	Cost ( 0, 0, 0 ): Variable Expression: a: char
642	(types:
643	lvalue char
644	)
645	Environment:
646
647	there are 1 alternatives before elimination
648	there are 1 alternatives after elimination
649	findSubExprs
650	Cost ( 0, 0, 0 ): Variable Expression: a: char
651	(types:
652	lvalue char
653	)
654	Environment:
655
656	nameExpr is b
657	decl is b: char
658	newExpr is Variable Expression: b: char
659
660	alternatives before prune:
661	Cost ( 0, 0, 0 ): Variable Expression: b: char
662	(types:
663	lvalue char
664	)
665	Environment:
666
667	there are 1 alternatives before elimination
668	there are 1 alternatives after elimination
669	findSubExprs
670	Cost ( 0, 0, 0 ): Variable Expression: b: char
671	(types:
672	lvalue char
673	)
674	Environment:
675
676	working on alternative:
677	Cost ( 0, 0, 0 ): Variable Expression: ?(): function
678	with parameters
679	number1: signed int
680	number2: signed int
681	returning
682	signed int
683
684	(types:
685	pointer to function
686	with parameters
687	number1: signed int
688	number2: signed int
689	returning
690	signed int
691
692	)
693	Environment:
694	formal type is signed int
695	actual type is lvalue char
696	formal type is signed int
697	actual type is lvalue char
698	need assertions:
699	============= original indexer
700	===idTable===
701	===typeTable===
702	===structTable===
703	===enumTable===
704	===unionTable===
705	===contextTable===
706	============= new indexer
707	===idTable===
708	===typeTable===
709	===structTable===
710	===enumTable===
711	===unionTable===
712	===contextTable===
713	working on alternative:
714	Cost ( 0, 0, 0 ): Variable Expression: ?(): function
715	with parameters
716	a: instance of struct accumulator
717	number1: char
718	number2: char
719	returning
720	char
721
722	(types:
723	pointer to function
724	with parameters
725	a: instance of struct accumulator
726	number1: char
727	number2: char
728	returning
729	char
730
731	)
732	Environment:
733	formal type is instance of struct accumulator
734	actual type is lvalue char
735	actual expression:
736	Variable Expression: a: char
737	--- results are
738	lvalue char
739
740	converting lvalue char
741	to signed int
742	cost is( 0, 0, 4 )
743	actual expression:
744	Variable Expression: b: char
745	--- results are
746	lvalue char
747
748	converting lvalue char
749	to signed int
750	cost is( 0, 0, 4 )
751	Case +++++++++++++
752	formals are:
753	number1: signed int
754	number2: signed int
755	actuals are:
756	Cast of:
757	Variable Expression: a: char
758
759	to:
760	signed int
761
762	Cast of:
763	Variable Expression: b: char
764
765	to:
766	signed int
767
768	bindings are:
769	cost of conversion is:( 0, 0, 8 )
770	alternatives before prune:
771	Cost ( 0, 0, 8 ): Application of
772	Variable Expression: ?(): function
773	with parameters
774	number1: signed int
775	number2: signed int
776	returning
777	signed int
778
779	to arguments
780	Cast of:
781	Variable Expression: a: char
782
783	to:
784	signed int
785
786	Cast of:
787	Variable Expression: b: char
788
789	to:
790	signed int
791
792	(types:
793	signed int
794	)
795	Environment:
796
797	there are 1 alternatives before elimination
798	there are 1 alternatives after elimination
799	alternatives before prune:
800	Cost ( 0, 0, 1 ): Cast of:
801	Application of
802	Variable Expression: ?(): function
803	with parameters
804	number1: signed int
805	number2: signed int
806	returning
807	signed int
808
809	to arguments
810	Cast of:
811	Variable Expression: a: char
812
813	to:
814	signed int
815
816	Cast of:
817	Variable Expression: b: char
818
819	to:
820	signed int
821
822
823	to:
824	nothing
825	(types:
826	)
827	Environment:
828
829	there are 1 alternatives before elimination
830	there are 1 alternatives after elimination
831	nameExpr is a
832	decl is a: char
833	newExpr is Variable Expression: a: char
834
835	alternatives before prune:
836	Cost ( 0, 0, 0 ): Variable Expression: a: char
837	(types:
838	lvalue char
839	)
840	Environment:
841
842	there are 1 alternatives before elimination
843	there are 1 alternatives after elimination
844	nameExpr is b
845	decl is b: char
846	newExpr is Variable Expression: b: char
847
848	alternatives before prune:
849	Cost ( 0, 0, 0 ): Variable Expression: b: char
850	(types:
851	lvalue char
852	)
853	Environment:
854
855	there are 1 alternatives before elimination
856	there are 1 alternatives after elimination
857	findSubExprs
858	Cost ( 0, 0, 0 ): Variable Expression: b: char
859	(types:
860	lvalue char
861	)
862	Environment:
863
864	working on alternative:
865	Cost ( 0, 0, 0 ): Variable Expression: a: char
866	(types:
867	lvalue char
868	)
869	Environment:
870	nameExpr is ?()
871	decl is ?(): function
872	with parameters
873	a: instance of struct accumulator
874	number1: char
875	number2: char
876	returning
877	char
878
879	newExpr is Variable Expression: ?(): function
880	with parameters
881	a: instance of struct accumulator
882	number1: char
883	number2: char
884	returning
885	char
886
887
888	decl is ?(): function
889	with parameters
890	number1: signed int
891	number2: signed int
892	returning
893	signed int
894	with body
895	CompoundStmt
896	Return Statement, returning: Cast of:
897	Application of
898	Variable Expression: ?*?: function
899	with parameters
900	signed int
901	signed int
902	returning
903	signed int
904
905	to arguments
906	Variable Expression: number1: signed int
907
908	Variable Expression: number2: signed int
909
910
911	to:
912	signed int
913	with environment:
914	Types:
915	Non-types:
916
917
918
919	newExpr is Variable Expression: ?(): function
920	with parameters
921	number1: signed int
922	number2: signed int
923	returning
924	signed int
925
926
927	alternatives before prune:
928	Cost ( 0, 0, 0 ): Variable Expression: ?(): function
929	with parameters
930	a: instance of struct accumulator
931	number1: char
932	number2: char
933	returning
934	char
935
936	(types:
937	pointer to function
938	with parameters
939	a: instance of struct accumulator
940	number1: char
941	number2: char
942	returning
943	char
944
945	)
946	Environment:
947
948	Cost ( 0, 0, 0 ): Variable Expression: ?(): function
949	with parameters
950	number1: signed int
951	number2: signed int
952	returning
953	signed int
954
955	(types:
956	pointer to function
957	with parameters
958	number1: signed int
959	number2: signed int
960	returning
961	signed int
962
963	)
964	Environment:
965
966	there are 2 alternatives before elimination
967	there are 2 alternatives after elimination
968	known function ops:
969	Cost ( 0, 0, 0 ): Variable Expression: ?(): function
970	with parameters
971	number1: signed int
972	number2: signed int
973	returning
974	signed int
975
976	(types:
977	pointer to function
978	with parameters
979	number1: signed int
980	number2: signed int
981	returning
982	signed int
983
984	)
985	Environment:
986
987	Cost ( 0, 0, 0 ): Variable Expression: ?(): function
988	with parameters
989	a: instance of struct accumulator
990	number1: char
991	number2: char
992	returning
993	char
994
995	(types:
996	pointer to function
997	with parameters
998	a: instance of struct accumulator
999	number1: char
1000	number2: char
1001	returning
1002	char
1003
1004	)
1005	Environment:
1006
1007	formal type is signed int
1008	actual type is lvalue char
1009	formal type is signed int
1010	actual type is lvalue char
1011	need assertions:
1012	============= original indexer
1013	===idTable===
1014	===typeTable===
1015	===structTable===
1016	===enumTable===
1017	===unionTable===
1018	===contextTable===
1019	============= new indexer
1020	===idTable===
1021	===typeTable===
1022	===structTable===
1023	===enumTable===
1024	===unionTable===
1025	===contextTable===
1026	formal type is instance of struct accumulator
1027	actual type is lvalue char
1028	actual expression:
1029	Variable Expression: a: char
1030	--- results are
1031	lvalue char
1032
1033	converting lvalue char
1034	to signed int
1035	cost is( 0, 0, 4 )
1036	actual expression:
1037	Variable Expression: b: char
1038	--- results are
1039	lvalue char
1040
1041	converting lvalue char
1042	to signed int
1043	cost is( 0, 0, 4 )
1044	Case +++++++++++++
1045	formals are:
1046	number1: signed int
1047	number2: signed int
1048	actuals are:
1049	Cast of:
1050	Variable Expression: a: char
1051
1052	to:
1053	signed int
1054
1055	Cast of:
1056	Variable Expression: b: char
1057
1058	to:
1059	signed int
1060
1061	bindings are:
1062	cost of conversion is:( 0, 0, 8 )
1063	alternatives before prune:
1064	Cost ( 0, 0, 8 ): Application of
1065	Variable Expression: ?(): function
1066	with parameters
1067	number1: signed int
1068	number2: signed int
1069	returning
1070	signed int
1071
1072	to arguments
1073	Cast of:
1074	Variable Expression: a: char
1075
1076	to:
1077	signed int
1078
1079	Cast of:
1080	Variable Expression: b: char
1081
1082	to:
1083	signed int
1084
1085	(types:
1086	signed int
1087	)
1088	Environment:
1089
1090	there are 1 alternatives before elimination
1091	there are 1 alternatives after elimination
1092	alternatives before prune:
1093	Cost ( 0, 0, 1 ): Cast of:
1094	Application of
1095	Variable Expression: ?(): function
1096	with parameters
1097	number1: signed int
1098	number2: signed int
1099	returning
1100	signed int
1101
1102	to arguments
1103	Cast of:
1104	Variable Expression: a: char
1105
1106	to:
1107	signed int
1108
1109	Cast of:
1110	Variable Expression: b: char
1111
1112	to:
1113	signed int
1114
1115
1116	to:
1117	nothing
1118	(types:
1119	)
1120	Environment:
1121
1122	there are 1 alternatives before elimination
1123	there are 1 alternatives after elimination
1124	nameExpr is ?+?
1125	decl is ?+?: function
1126	with parameters
1127	signed int
1128	signed int
1129	returning
1130	signed int
1131
1132	newExpr is Variable Expression: ?+?: function
1133	with parameters
1134	signed int
1135	signed int
1136	returning
1137	signed int
1138
1139
1140	alternatives before prune:
1141	Cost ( 0, 0, 0 ): Variable Expression: ?+?: function
1142	with parameters
1143	signed int
1144	signed int
1145	returning
1146	signed int
1147
1148	(types:
1149	pointer to function
1150	with parameters
1151	signed int
1152	signed int
1153	returning
1154	signed int
1155
1156	)
1157	Environment:
1158
1159	there are 1 alternatives before elimination
1160	there are 1 alternatives after elimination
1161	nameExpr is a
1162	decl is a: char
1163	newExpr is Variable Expression: a: char
1164
1165	alternatives before prune:
1166	Cost ( 0, 0, 0 ): Variable Expression: a: char
1167	(types:
1168	lvalue char
1169	)
1170	Environment:
1171
1172	there are 1 alternatives before elimination
1173	there are 1 alternatives after elimination
1174	findSubExprs
1175	Cost ( 0, 0, 0 ): Variable Expression: a: char
1176	(types:
1177	lvalue char
1178	)
1179	Environment:
1180
1181	nameExpr is b
1182	decl is b: char
1183	newExpr is Variable Expression: b: char
1184
1185	alternatives before prune:
1186	Cost ( 0, 0, 0 ): Variable Expression: b: char
1187	(types:
1188	lvalue char
1189	)
1190	Environment:
1191
1192	there are 1 alternatives before elimination
1193	there are 1 alternatives after elimination
1194	findSubExprs
1195	Cost ( 0, 0, 0 ): Variable Expression: b: char
1196	(types:
1197	lvalue char
1198	)
1199	Environment:
1200
1201	working on alternative:
1202	Cost ( 0, 0, 0 ): Variable Expression: ?+?: function
1203	with parameters
1204	signed int
1205	signed int
1206	returning
1207	signed int
1208
1209	(types:
1210	pointer to function
1211	with parameters
1212	signed int
1213	signed int
1214	returning
1215	signed int
1216
1217	)
1218	Environment:
1219	formal type is signed int
1220	actual type is lvalue char
1221	formal type is signed int
1222	actual type is lvalue char
1223	need assertions:
1224	============= original indexer
1225	===idTable===
1226	===typeTable===
1227	===structTable===
1228	===enumTable===
1229	===unionTable===
1230	===contextTable===
1231	============= new indexer
1232	===idTable===
1233	===typeTable===
1234	===structTable===
1235	===enumTable===
1236	===unionTable===
1237	===contextTable===
1238	actual expression:
1239	Variable Expression: a: char
1240	--- results are
1241	lvalue char
1242
1243	converting lvalue char
1244	to signed int
1245	cost is( 0, 0, 4 )
1246	actual expression:
1247	Variable Expression: b: char
1248	--- results are
1249	lvalue char
1250
1251	converting lvalue char
1252	to signed int
1253	cost is( 0, 0, 4 )
1254	Case +++++++++++++
1255	formals are:
1256	signed int
1257	signed int
1258	actuals are:
1259	Cast of:
1260	Variable Expression: a: char
1261
1262	to:
1263	signed int
1264
1265	Cast of:
1266	Variable Expression: b: char
1267
1268	to:
1269	signed int
1270
1271	bindings are:
1272	cost of conversion is:( 0, 0, 8 )
1273	alternatives before prune:
1274	Cost ( 0, 0, 8 ): Application of
1275	Variable Expression: ?+?: function
1276	with parameters
1277	signed int
1278	signed int
1279	returning
1280	signed int
1281
1282	to arguments
1283	Cast of:
1284	Variable Expression: a: char
1285
1286	to:
1287	signed int
1288
1289	Cast of:
1290	Variable Expression: b: char
1291
1292	to:
1293	signed int
1294
1295	(types:
1296	signed int
1297	)
1298	Environment:
1299
1300	there are 1 alternatives before elimination
1301	there are 1 alternatives after elimination
1302	alternatives before prune:
1303	Cost ( 0, 0, 1 ): Cast of:
1304	Application of
1305	Variable Expression: ?+?: function
1306	with parameters
1307	signed int
1308	signed int
1309	returning
1310	signed int
1311
1312	to arguments
1313	Cast of:
1314	Variable Expression: a: char
1315
1316	to:
1317	signed int
1318
1319	Cast of:
1320	Variable Expression: b: char
1321
1322	to:
1323	signed int
1324
1325
1326	to:
1327	nothing
1328	(types:
1329	)
1330	Environment:
1331
1332	there are 1 alternatives before elimination
1333	there are 1 alternatives after elimination
1334	nameExpr is ?+?
1335	decl is ?+?: instance of struct accumulator
1336	newExpr is Variable Expression: ?+?: instance of struct accumulator
1337
1338	decl is ?+?: function
1339	with parameters
1340	signed int
1341	signed int
1342	returning
1343	signed int
1344
1345	newExpr is Variable Expression: ?+?: function
1346	with parameters
1347	signed int
1348	signed int
1349	returning
1350	signed int
1351
1352
1353	alternatives before prune:
1354	Cost ( 0, 0, 0 ): Variable Expression: ?+?: instance of struct accumulator
1355	(types:
1356	lvalue instance of struct accumulator
1357	)
1358	Environment:
1359
1360	Cost ( 0, 0, 0 ): Variable Expression: ?+?: function
1361	with parameters
1362	signed int
1363	signed int
1364	returning
1365	signed int
1366
1367	(types:
1368	pointer to function
1369	with parameters
1370	signed int
1371	signed int
1372	returning
1373	signed int
1374
1375	)
1376	Environment:
1377
1378	there are 2 alternatives before elimination
1379	there are 2 alternatives after elimination
1380	nameExpr is a
1381	decl is a: char
1382	newExpr is Variable Expression: a: char
1383
1384	alternatives before prune:
1385	Cost ( 0, 0, 0 ): Variable Expression: a: char
1386	(types:
1387	lvalue char
1388	)
1389	Environment:
1390
1391	there are 1 alternatives before elimination
1392	there are 1 alternatives after elimination
1393	findSubExprs
1394	Cost ( 0, 0, 0 ): Variable Expression: a: char
1395	(types:
1396	lvalue char
1397	)
1398	Environment:
1399
1400	nameExpr is b
1401	decl is b: char
1402	newExpr is Variable Expression: b: char
1403
1404	alternatives before prune:
1405	Cost ( 0, 0, 0 ): Variable Expression: b: char
1406	(types:
1407	lvalue char
1408	)
1409	Environment:
1410
1411	there are 1 alternatives before elimination
1412	there are 1 alternatives after elimination
1413	findSubExprs
1414	Cost ( 0, 0, 0 ): Variable Expression: b: char
1415	(types:
1416	lvalue char
1417	)
1418	Environment:
1419
1420	working on alternative:
1421	Cost ( 0, 0, 0 ): Variable Expression: ?+?: function
1422	with parameters
1423	signed int
1424	signed int
1425	returning
1426	signed int
1427
1428	(types:
1429	pointer to function
1430	with parameters
1431	signed int
1432	signed int
1433	returning
1434	signed int
1435
1436	)
1437	Environment:
1438	formal type is signed int
1439	actual type is lvalue char
1440	formal type is signed int
1441	actual type is lvalue char
1442	need assertions:
1443	============= original indexer
1444	===idTable===
1445	===typeTable===
1446	===structTable===
1447	===enumTable===
1448	===unionTable===
1449	===contextTable===
1450	============= new indexer
1451	===idTable===
1452	===typeTable===
1453	===structTable===
1454	===enumTable===
1455	===unionTable===
1456	===contextTable===
1457	working on alternative:
1458	Cost ( 0, 0, 0 ): Variable Expression: ?+?: instance of struct accumulator
1459	(types:
1460	lvalue instance of struct accumulator
1461	)
1462	Environment:
1463	nameExpr is ?()
1464	decl is ?(): function
1465	with parameters
1466	a: instance of struct accumulator
1467	number1: char
1468	number2: char
1469	returning
1470	char
1471
1472	newExpr is Variable Expression: ?(): function
1473	with parameters
1474	a: instance of struct accumulator
1475	number1: char
1476	number2: char
1477	returning
1478	char
1479
1480
1481	decl is ?(): function
1482	with parameters
1483	number1: signed int
1484	number2: signed int
1485	returning
1486	signed int
1487	with body
1488	CompoundStmt
1489	Return Statement, returning: Cast of:
1490	Application of
1491	Variable Expression: ?*?: function
1492	with parameters
1493	signed int
1494	signed int
1495	returning
1496	signed int
1497
1498	to arguments
1499	Variable Expression: number1: signed int
1500
1501	Variable Expression: number2: signed int
1502
1503
1504	to:
1505	signed int
1506	with environment:
1507	Types:
1508	Non-types:
1509
1510
1511
1512	newExpr is Variable Expression: ?(): function
1513	with parameters
1514	number1: signed int
1515	number2: signed int
1516	returning
1517	signed int
1518
1519
1520	alternatives before prune:
1521	Cost ( 0, 0, 0 ): Variable Expression: ?(): function
1522	with parameters
1523	a: instance of struct accumulator
1524	number1: char
1525	number2: char
1526	returning
1527	char
1528
1529	(types:
1530	pointer to function
1531	with parameters
1532	a: instance of struct accumulator
1533	number1: char
1534	number2: char
1535	returning
1536	char
1537
1538	)
1539	Environment:
1540
1541	Cost ( 0, 0, 0 ): Variable Expression: ?(): function
1542	with parameters
1543	number1: signed int
1544	number2: signed int
1545	returning
1546	signed int
1547
1548	(types:
1549	pointer to function
1550	with parameters
1551	number1: signed int
1552	number2: signed int
1553	returning
1554	signed int
1555
1556	)
1557	Environment:
1558
1559	there are 2 alternatives before elimination
1560	there are 2 alternatives after elimination
1561	known function ops:
1562	Cost ( 0, 0, 0 ): Variable Expression: ?(): function
1563	with parameters
1564	number1: signed int
1565	number2: signed int
1566	returning
1567	signed int
1568
1569	(types:
1570	pointer to function
1571	with parameters
1572	number1: signed int
1573	number2: signed int
1574	returning
1575	signed int
1576
1577	)
1578	Environment:
1579
1580	Cost ( 0, 0, 0 ): Variable Expression: ?(): function
1581	with parameters
1582	a: instance of struct accumulator
1583	number1: char
1584	number2: char
1585	returning
1586	char
1587
1588	(types:
1589	pointer to function
1590	with parameters
1591	a: instance of struct accumulator
1592	number1: char
1593	number2: char
1594	returning
1595	char
1596
1597	)
1598	Environment:
1599
1600	formal type is signed int
1601	actual type is lvalue instance of struct accumulator
1602	formal type is instance of struct accumulator
1603	actual type is lvalue instance of struct accumulator
1604	formal type is char
1605	actual type is lvalue char
1606	formal type is char
1607	actual type is lvalue char
1608	need assertions:
1609	============= original indexer
1610	===idTable===
1611	===typeTable===
1612	===structTable===
1613	===enumTable===
1614	===unionTable===
1615	===contextTable===
1616	============= new indexer
1617	===idTable===
1618	===typeTable===
1619	===structTable===
1620	===enumTable===
1621	===unionTable===
1622	===contextTable===
1623	actual expression:
1624	Variable Expression: a: char
1625	--- results are
1626	lvalue char
1627
1628	converting lvalue char
1629	to signed int
1630	cost is( 0, 0, 4 )
1631	actual expression:
1632	Variable Expression: b: char
1633	--- results are
1634	lvalue char
1635
1636	converting lvalue char
1637	to signed int
1638	cost is( 0, 0, 4 )
1639	Case +++++++++++++
1640	formals are:
1641	signed int
1642	signed int
1643	actuals are:
1644	Cast of:
1645	Variable Expression: a: char
1646
1647	to:
1648	signed int
1649
1650	Cast of:
1651	Variable Expression: b: char
1652
1653	to:
1654	signed int
1655
1656	bindings are:
1657	cost of conversion is:( 0, 0, 8 )
1658	actual expression:
1659	Variable Expression: ?+?: instance of struct accumulator
1660	--- results are
1661	lvalue instance of struct accumulator
1662
1663	converting lvalue instance of struct accumulator
1664	to instance of struct accumulator
1665	cost is( 0, 0, 0 )
1666	actual expression:
1667	Variable Expression: a: char
1668	--- results are
1669	lvalue char
1670
1671	converting lvalue char
1672	to char
1673	cost is( 0, 0, 0 )
1674	actual expression:
1675	Variable Expression: b: char
1676	--- results are
1677	lvalue char
1678
1679	converting lvalue char
1680	to char
1681	cost is( 0, 0, 0 )
1682	Case +++++++++++++
1683	formals are:
1684	a: instance of struct accumulator
1685	number1: char
1686	number2: char
1687	actuals are:
1688	Variable Expression: ?+?: instance of struct accumulator
1689
1690	Variable Expression: a: char
1691
1692	Variable Expression: b: char
1693
1694	bindings are:
1695	cost of conversion is:( 0, 0, 0 )
1696	alternatives before prune:
1697	Cost ( 0, 0, 8 ): Application of
1698	Variable Expression: ?+?: function
1699	with parameters
1700	signed int
1701	signed int
1702	returning
1703	signed int
1704
1705	to arguments
1706	Cast of:
1707	Variable Expression: a: char
1708
1709	to:
1710	signed int
1711
1712	Cast of:
1713	Variable Expression: b: char
1714
1715	to:
1716	signed int
1717
1718	(types:
1719	signed int
1720	)
1721	Environment:
1722
1723	Cost ( 0, 0, 0 ): Application of
1724	Variable Expression: ?(): function
1725	with parameters
1726	a: instance of struct accumulator
1727	number1: char
1728	number2: char
1729	returning
1730	char
1731
1732	to arguments
1733	Variable Expression: ?+?: instance of struct accumulator
1734
1735	Variable Expression: a: char
1736
1737	Variable Expression: b: char
1738
1739	(types:
1740	char
1741	)
1742	Environment:
1743
1744	there are 2 alternatives before elimination
1745	there are 2 alternatives after elimination
1746	alternatives before prune:
1747	Cost ( 0, 0, 1 ): Cast of:
1748	Application of
1749	Variable Expression: ?(): function
1750	with parameters
1751	a: instance of struct accumulator
1752	number1: char
1753	number2: char
1754	returning
1755	char
1756
1757	to arguments
1758	Variable Expression: ?+?: instance of struct accumulator
1759
1760	Variable Expression: a: char
1761
1762	Variable Expression: b: char
1763
1764
1765	to:
1766	nothing
1767	(types:
1768	)
1769	Environment:
1770
1771	there are 1 alternatives before elimination
1772	there are 1 alternatives after elimination
1773	int ___operator_multiply__Fi_ii_(int , int );
1774	int ___operator_call__Fi_ii_(int __number1__i, int __number2__i){
1775	return ___operator_multiply__Fi_ii_(__number1__i, __number2__i);
1776	}
1777	int ___operator_add__Fi_ii_(int , int );
1778	int ___operator_assign__Fi_Pii_(int *, int );
1779	struct accumulator
1780	{
1781	int __total__i;
1782	};
1783	static inline struct accumulator ___operator_assign__F12saccumulator_P12saccumulator12saccumulator_(struct accumulator *___dst__P12saccumulator, struct accumulator ___src__12saccumulator){
1784	___operator_assign__Fi_Pii_((&(*___dst__P12saccumulator).__total__i), ___src__12saccumulator.__total__i);
1785	return ___src__12saccumulator;
1786	}
1787	char ___operator_call__Fc_12saccumulatorcc_(struct accumulator __a__12saccumulator, char __number1__c, char __number2__c);
1788	void __f__F__(void){
1789	char __a__c;
1790	char __b__c;
1791	___operator_call__Fi_ii_(((int )__a__c), ((int )__b__c));
1792	___operator_call__Fi_ii_(((int )__a__c), ((int )__b__c));
1793	___operator_add__Fi_ii_(((int )__a__c), ((int )__b__c));
1794	struct accumulator ___operator_add__12saccumulator;
1795	___operator_call__Fc_12saccumulatorcc_(___operator_add__12saccumulator, __a__c, __b__c);
1796	}

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

Download in other formats: