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

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsctordeferred_resndemanglerenumforall-pointer-decaygc_noraiijacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newstringwith_gc
Last change on this file since a1d5d2a 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: 60.5 KB
Line 
1nameExpr is g
2decl is g: function
3  with parameters
4    float
5  returning
6    nothing
7
8newExpr is Variable Expression: g: function
9    with parameters
10      float
11    returning
12      nothing
13
14
15decl is g: function
16  with parameters
17    signed int
18  returning
19    nothing
20
21newExpr is Variable Expression: g: function
22    with parameters
23      signed int
24    returning
25      nothing
26
27
28alternatives before prune:
29Cost ( 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)
43Environment:
44
45Cost ( 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)
59Environment:
60
61there are 2 alternatives before elimination
62there are 2 alternatives after elimination
63nameExpr is ?!=?
64decl is ?!=?: function
65  with parameters
66    float
67    float
68  returning
69    signed int
70
71newExpr is Variable Expression: ?!=?: function
72    with parameters
73      float
74      float
75    returning
76      signed int
77
78
79decl is ?!=?: function
80  with parameters
81    signed int
82    signed int
83  returning
84    signed int
85
86newExpr is Variable Expression: ?!=?: function
87    with parameters
88      signed int
89      signed int
90    returning
91      signed int
92
93
94alternatives before prune:
95Cost ( 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)
111Environment:
112
113Cost ( 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)
129Environment:
130
131there are 2 alternatives before elimination
132there are 2 alternatives after elimination
133nameExpr is a
134decl is a: signed int
135newExpr is Variable Expression: a: signed int
136
137alternatives before prune:
138Cost ( 0, 0, 0 ): Variable Expression: a: signed int
139(types:
140    lvalue signed int
141)
142Environment:
143
144there are 1 alternatives before elimination
145there are 1 alternatives after elimination
146findSubExprs
147Cost ( 0, 0, 0 ): Variable Expression: a: signed int
148(types:
149    lvalue signed int
150)
151Environment:
152
153nameExpr is 0
154decl is 0: signed int
155newExpr is Variable Expression: 0: signed int
156
157alternatives before prune:
158Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
159(types:
160    lvalue signed int
161)
162Environment:
163
164there are 1 alternatives before elimination
165there are 1 alternatives after elimination
166findSubExprs
167Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
168(types:
169    lvalue signed int
170)
171Environment:
172
173working 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:
191formal type is signed int
192actual type is lvalue signed int
193formal type is signed int
194actual type is lvalue signed int
195need 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===
210working 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:
228formal type is float
229actual type is lvalue signed int
230formal type is float
231actual type is lvalue signed int
232need 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===
247actual expression:
248        Variable Expression: a: signed int
249--- results are
250        lvalue signed int
251
252converting lvalue signed int
253 to signed int
254cost is( 0, 0, 0 )
255actual expression:
256        Variable Expression: 0: signed int
257--- results are
258        lvalue signed int
259
260converting lvalue signed int
261 to signed int
262cost is( 0, 0, 0 )
263Case +++++++++++++
264formals are:
265        signed int
266        signed int
267actuals are:
268                  Variable Expression: a: signed int
269
270                  Variable Expression: 0: signed int
271
272bindings are:
273cost of conversion is:( 0, 0, 0 )
274actual expression:
275        Variable Expression: a: signed int
276--- results are
277        lvalue signed int
278
279converting lvalue signed int
280 to float
281cost is( 0, 0, 5 )
282actual expression:
283        Variable Expression: 0: signed int
284--- results are
285        lvalue signed int
286
287converting lvalue signed int
288 to float
289cost is( 0, 0, 5 )
290Case +++++++++++++
291formals are:
292        float
293        float
294actuals 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
307bindings are:
308cost of conversion is:( 0, 0, 10 )
309alternatives before prune:
310Cost ( 0, 0, 0 ): Application of
311  Variable Expression: ?!=?: function
312      with parameters
313        signed int
314        signed int
315      returning
316        signed int
317
318to arguments
319      Variable Expression: a: signed int
320
321      Variable Expression: 0: signed int
322
323(types:
324    signed int
325)
326Environment:
327
328Cost ( 0, 0, 10 ): Application of
329  Variable Expression: ?!=?: function
330      with parameters
331        float
332        float
333      returning
334        signed int
335
336to 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)
352Environment:
353
354there are 1 alternatives before elimination
355there are 1 alternatives after elimination
356alternatives before prune:
357Cost ( 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
372to:
373  signed int
374(types:
375    signed int
376)
377Environment:
378
379there are 1 alternatives before elimination
380there are 1 alternatives after elimination
381nameExpr is b
382decl is b: signed int
383newExpr is Variable Expression: b: signed int
384
385alternatives before prune:
386Cost ( 0, 0, 0 ): Variable Expression: b: signed int
387(types:
388    lvalue signed int
389)
390Environment:
391
392there are 1 alternatives before elimination
393there are 1 alternatives after elimination
394nameExpr is c
395decl is c: float
396newExpr is Variable Expression: c: float
397
398alternatives before prune:
399Cost ( 0, 0, 0 ): Variable Expression: c: float
400(types:
401    lvalue float
402)
403Environment:
404
405there are 1 alternatives before elimination
406there 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===
421alternatives before prune:
422Cost ( 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
440First alternative:
441  Variable Expression: b: signed int
442Second alternative:
443  Variable Expression: c: float
444
445(types:
446    lvalue float
447)
448Environment:
449
450there are 1 alternatives before elimination
451there are 1 alternatives after elimination
452findSubExprs
453Cost ( 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
471First alternative:
472  Variable Expression: b: signed int
473Second alternative:
474  Variable Expression: c: float
475
476(types:
477    lvalue float
478)
479Environment:
480
481working 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:
497formal type is signed int
498actual type is lvalue float
499need 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===
514working 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:
530formal type is float
531actual type is lvalue float
532need 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===
547actual 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
574converting lvalue float
575 to signed int
576cost is( 1, 0, 0 )
577Case +++++++++++++
578formals are:
579        signed int
580actuals 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
609bindings are:
610cost of conversion is:( 1, 0, 0 )
611actual 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
638converting lvalue float
639 to float
640cost is( 0, 0, 0 )
641Case +++++++++++++
642formals are:
643        float
644actuals 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
669bindings are:
670cost of conversion is:( 0, 0, 0 )
671alternatives before prune:
672Cost ( 1, 0, 0 ): Application of
673  Variable Expression: g: function
674      with parameters
675        signed int
676      returning
677        nothing
678
679to 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)
710Environment:
711
712Cost ( 0, 0, 0 ): Application of
713  Variable Expression: g: function
714      with parameters
715        float
716      returning
717        nothing
718
719to 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)
746Environment:
747
748cost ( 0, 0, 0 ) beats ( 1, 0, 0 )
749there are 1 alternatives before elimination
750there are 1 alternatives after elimination
751alternatives before prune:
752Cost ( 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
786to:
787  nothing
788(types:
789)
790Environment:
791
792there are 1 alternatives before elimination
793there are 1 alternatives after elimination
794nameExpr is g
795decl is g: function
796  with parameters
797    float
798  returning
799    nothing
800
801newExpr is Variable Expression: g: function
802    with parameters
803      float
804    returning
805      nothing
806
807
808decl is g: function
809  with parameters
810    signed int
811  returning
812    nothing
813
814newExpr is Variable Expression: g: function
815    with parameters
816      signed int
817    returning
818      nothing
819
820
821alternatives before prune:
822Cost ( 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)
836Environment:
837
838Cost ( 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)
852Environment:
853
854there are 2 alternatives before elimination
855there are 2 alternatives after elimination
856nameExpr is ?!=?
857decl is ?!=?: function
858  with parameters
859    float
860    float
861  returning
862    signed int
863
864newExpr is Variable Expression: ?!=?: function
865    with parameters
866      float
867      float
868    returning
869      signed int
870
871
872decl is ?!=?: function
873  with parameters
874    signed int
875    signed int
876  returning
877    signed int
878
879newExpr is Variable Expression: ?!=?: function
880    with parameters
881      signed int
882      signed int
883    returning
884      signed int
885
886
887alternatives before prune:
888Cost ( 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)
904Environment:
905
906Cost ( 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)
922Environment:
923
924there are 2 alternatives before elimination
925there are 2 alternatives after elimination
926nameExpr is a
927decl is a: signed int
928newExpr is Variable Expression: a: signed int
929
930alternatives before prune:
931Cost ( 0, 0, 0 ): Variable Expression: a: signed int
932(types:
933    lvalue signed int
934)
935Environment:
936
937there are 1 alternatives before elimination
938there are 1 alternatives after elimination
939findSubExprs
940Cost ( 0, 0, 0 ): Variable Expression: a: signed int
941(types:
942    lvalue signed int
943)
944Environment:
945
946nameExpr is 0
947decl is 0: signed int
948newExpr is Variable Expression: 0: signed int
949
950alternatives before prune:
951Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
952(types:
953    lvalue signed int
954)
955Environment:
956
957there are 1 alternatives before elimination
958there are 1 alternatives after elimination
959findSubExprs
960Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
961(types:
962    lvalue signed int
963)
964Environment:
965
966working 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:
984formal type is signed int
985actual type is lvalue signed int
986formal type is signed int
987actual type is lvalue signed int
988need 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===
1003working 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:
1021formal type is float
1022actual type is lvalue signed int
1023formal type is float
1024actual type is lvalue signed int
1025need 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===
1040actual expression:
1041        Variable Expression: a: signed int
1042--- results are
1043        lvalue signed int
1044
1045converting lvalue signed int
1046 to signed int
1047cost is( 0, 0, 0 )
1048actual expression:
1049        Variable Expression: 0: signed int
1050--- results are
1051        lvalue signed int
1052
1053converting lvalue signed int
1054 to signed int
1055cost is( 0, 0, 0 )
1056Case +++++++++++++
1057formals are:
1058        signed int
1059        signed int
1060actuals are:
1061                  Variable Expression: a: signed int
1062
1063                  Variable Expression: 0: signed int
1064
1065bindings are:
1066cost of conversion is:( 0, 0, 0 )
1067actual expression:
1068        Variable Expression: a: signed int
1069--- results are
1070        lvalue signed int
1071
1072converting lvalue signed int
1073 to float
1074cost is( 0, 0, 5 )
1075actual expression:
1076        Variable Expression: 0: signed int
1077--- results are
1078        lvalue signed int
1079
1080converting lvalue signed int
1081 to float
1082cost is( 0, 0, 5 )
1083Case +++++++++++++
1084formals are:
1085        float
1086        float
1087actuals 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
1100bindings are:
1101cost of conversion is:( 0, 0, 10 )
1102alternatives before prune:
1103Cost ( 0, 0, 0 ): Application of
1104  Variable Expression: ?!=?: function
1105      with parameters
1106        signed int
1107        signed int
1108      returning
1109        signed int
1110
1111to arguments
1112      Variable Expression: a: signed int
1113
1114      Variable Expression: 0: signed int
1115
1116(types:
1117    signed int
1118)
1119Environment:
1120
1121Cost ( 0, 0, 10 ): Application of
1122  Variable Expression: ?!=?: function
1123      with parameters
1124        float
1125        float
1126      returning
1127        signed int
1128
1129to 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)
1145Environment:
1146
1147there are 1 alternatives before elimination
1148there are 1 alternatives after elimination
1149alternatives before prune:
1150Cost ( 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
1165to:
1166  signed int
1167(types:
1168    signed int
1169)
1170Environment:
1171
1172there are 1 alternatives before elimination
1173there are 1 alternatives after elimination
1174nameExpr is ?!=?
1175decl is ?!=?: function
1176  with parameters
1177    float
1178    float
1179  returning
1180    signed int
1181
1182newExpr is Variable Expression: ?!=?: function
1183    with parameters
1184      float
1185      float
1186    returning
1187      signed int
1188
1189
1190decl is ?!=?: function
1191  with parameters
1192    signed int
1193    signed int
1194  returning
1195    signed int
1196
1197newExpr is Variable Expression: ?!=?: function
1198    with parameters
1199      signed int
1200      signed int
1201    returning
1202      signed int
1203
1204
1205alternatives before prune:
1206Cost ( 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)
1222Environment:
1223
1224Cost ( 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)
1240Environment:
1241
1242there are 2 alternatives before elimination
1243there are 2 alternatives after elimination
1244nameExpr is c
1245decl is c: float
1246newExpr is Variable Expression: c: float
1247
1248alternatives before prune:
1249Cost ( 0, 0, 0 ): Variable Expression: c: float
1250(types:
1251    lvalue float
1252)
1253Environment:
1254
1255there are 1 alternatives before elimination
1256there are 1 alternatives after elimination
1257findSubExprs
1258Cost ( 0, 0, 0 ): Variable Expression: c: float
1259(types:
1260    lvalue float
1261)
1262Environment:
1263
1264nameExpr is 0
1265decl is 0: signed int
1266newExpr is Variable Expression: 0: signed int
1267
1268alternatives before prune:
1269Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
1270(types:
1271    lvalue signed int
1272)
1273Environment:
1274
1275there are 1 alternatives before elimination
1276there are 1 alternatives after elimination
1277findSubExprs
1278Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
1279(types:
1280    lvalue signed int
1281)
1282Environment:
1283
1284working 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:
1302formal type is signed int
1303actual type is lvalue float
1304formal type is signed int
1305actual type is lvalue signed int
1306need 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===
1321working 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:
1339formal type is float
1340actual type is lvalue float
1341formal type is float
1342actual type is lvalue signed int
1343need 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===
1358actual expression:
1359        Variable Expression: c: float
1360--- results are
1361        lvalue float
1362
1363converting lvalue float
1364 to signed int
1365cost is( 1, 0, 0 )
1366actual expression:
1367        Variable Expression: 0: signed int
1368--- results are
1369        lvalue signed int
1370
1371converting lvalue signed int
1372 to signed int
1373cost is( 0, 0, 0 )
1374Case +++++++++++++
1375formals are:
1376        signed int
1377        signed int
1378actuals are:
1379                  Cast of:
1380            Variable Expression: c: float
1381
1382          to:
1383            signed int
1384
1385                  Variable Expression: 0: signed int
1386
1387bindings are:
1388cost of conversion is:( 1, 0, 0 )
1389actual expression:
1390        Variable Expression: c: float
1391--- results are
1392        lvalue float
1393
1394converting lvalue float
1395 to float
1396cost is( 0, 0, 0 )
1397actual expression:
1398        Variable Expression: 0: signed int
1399--- results are
1400        lvalue signed int
1401
1402converting lvalue signed int
1403 to float
1404cost is( 0, 0, 5 )
1405Case +++++++++++++
1406formals are:
1407        float
1408        float
1409actuals are:
1410                  Variable Expression: c: float
1411
1412                  Cast of:
1413            Variable Expression: 0: signed int
1414
1415          to:
1416            float
1417
1418bindings are:
1419cost of conversion is:( 0, 0, 5 )
1420alternatives before prune:
1421Cost ( 1, 0, 0 ): Application of
1422  Variable Expression: ?!=?: function
1423      with parameters
1424        signed int
1425        signed int
1426      returning
1427        signed int
1428
1429to 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)
1441Environment:
1442
1443Cost ( 0, 0, 5 ): Application of
1444  Variable Expression: ?!=?: function
1445      with parameters
1446        float
1447        float
1448      returning
1449        signed int
1450
1451to 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)
1463Environment:
1464
1465cost ( 0, 0, 5 ) beats ( 1, 0, 0 )
1466there are 1 alternatives before elimination
1467there are 1 alternatives after elimination
1468alternatives before prune:
1469Cost ( 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
1488to:
1489  signed int
1490(types:
1491    signed int
1492)
1493Environment:
1494
1495there are 1 alternatives before elimination
1496there are 1 alternatives after elimination
1497alternatives before prune:
1498Cost ( 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
1513to:
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
1534to:
1535  signed int
1536
1537(types:
1538    signed int
1539)
1540Environment:
1541
1542there are 1 alternatives before elimination
1543there are 1 alternatives after elimination
1544findSubExprs
1545Cost ( 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
1560to:
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
1581to:
1582  signed int
1583
1584(types:
1585    signed int
1586)
1587Environment:
1588
1589working 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:
1605formal type is signed int
1606actual type is signed int
1607need 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===
1622working 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:
1638formal type is float
1639actual type is signed int
1640need 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===
1655actual 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
1671to:
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
1692to:
1693  signed int
1694
1695--- results are
1696        signed int
1697
1698converting signed int
1699 to signed int
1700cost is( 0, 0, 0 )
1701Case +++++++++++++
1702formals are:
1703        signed int
1704actuals 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
1720to:
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
1741to:
1742  signed int
1743
1744
1745bindings are:
1746cost of conversion is:( 0, 0, 0 )
1747actual 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
1763to:
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
1784to:
1785  signed int
1786
1787--- results are
1788        signed int
1789
1790converting signed int
1791 to float
1792cost is( 0, 0, 5 )
1793Case +++++++++++++
1794formals are:
1795        float
1796actuals 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
1813to:
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
1834to:
1835  signed int
1836
1837
1838          to:
1839            float
1840
1841bindings are:
1842cost of conversion is:( 0, 0, 5 )
1843alternatives before prune:
1844Cost ( 0, 0, 0 ): Application of
1845  Variable Expression: g: function
1846      with parameters
1847        signed int
1848      returning
1849        nothing
1850
1851to 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
1867to:
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
1888to:
1889  signed int
1890
1891
1892(types:
1893)
1894Environment:
1895
1896Cost ( 0, 0, 5 ): Application of
1897  Variable Expression: g: function
1898      with parameters
1899        float
1900      returning
1901        nothing
1902
1903to 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
1920to:
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
1941to:
1942  signed int
1943
1944
1945    to:
1946      float
1947
1948(types:
1949)
1950Environment:
1951
1952there are 1 alternatives before elimination
1953there are 1 alternatives after elimination
1954alternatives before prune:
1955Cost ( 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
1979to:
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
2000to:
2001  signed int
2002
2003
2004
2005to:
2006  nothing
2007(types:
2008)
2009Environment:
2010
2011there are 1 alternatives before elimination
2012there are 1 alternatives after elimination
2013nameExpr is g
2014decl is g: function
2015  with parameters
2016    float
2017  returning
2018    nothing
2019
2020newExpr is Variable Expression: g: function
2021    with parameters
2022      float
2023    returning
2024      nothing
2025
2026
2027decl is g: function
2028  with parameters
2029    signed int
2030  returning
2031    nothing
2032
2033newExpr is Variable Expression: g: function
2034    with parameters
2035      signed int
2036    returning
2037      nothing
2038
2039
2040alternatives before prune:
2041Cost ( 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)
2055Environment:
2056
2057Cost ( 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)
2071Environment:
2072
2073there are 2 alternatives before elimination
2074there are 2 alternatives after elimination
2075nameExpr is ?!=?
2076decl is ?!=?: function
2077  with parameters
2078    float
2079    float
2080  returning
2081    signed int
2082
2083newExpr is Variable Expression: ?!=?: function
2084    with parameters
2085      float
2086      float
2087    returning
2088      signed int
2089
2090
2091decl is ?!=?: function
2092  with parameters
2093    signed int
2094    signed int
2095  returning
2096    signed int
2097
2098newExpr is Variable Expression: ?!=?: function
2099    with parameters
2100      signed int
2101      signed int
2102    returning
2103      signed int
2104
2105
2106alternatives before prune:
2107Cost ( 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)
2123Environment:
2124
2125Cost ( 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)
2141Environment:
2142
2143there are 2 alternatives before elimination
2144there are 2 alternatives after elimination
2145nameExpr is a
2146decl is a: signed int
2147newExpr is Variable Expression: a: signed int
2148
2149alternatives before prune:
2150Cost ( 0, 0, 0 ): Variable Expression: a: signed int
2151(types:
2152    lvalue signed int
2153)
2154Environment:
2155
2156there are 1 alternatives before elimination
2157there are 1 alternatives after elimination
2158findSubExprs
2159Cost ( 0, 0, 0 ): Variable Expression: a: signed int
2160(types:
2161    lvalue signed int
2162)
2163Environment:
2164
2165nameExpr is 0
2166decl is 0: signed int
2167newExpr is Variable Expression: 0: signed int
2168
2169alternatives before prune:
2170Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
2171(types:
2172    lvalue signed int
2173)
2174Environment:
2175
2176there are 1 alternatives before elimination
2177there are 1 alternatives after elimination
2178findSubExprs
2179Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
2180(types:
2181    lvalue signed int
2182)
2183Environment:
2184
2185working 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:
2203formal type is signed int
2204actual type is lvalue signed int
2205formal type is signed int
2206actual type is lvalue signed int
2207need 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===
2222working 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:
2240formal type is float
2241actual type is lvalue signed int
2242formal type is float
2243actual type is lvalue signed int
2244need 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===
2259actual expression:
2260        Variable Expression: a: signed int
2261--- results are
2262        lvalue signed int
2263
2264converting lvalue signed int
2265 to signed int
2266cost is( 0, 0, 0 )
2267actual expression:
2268        Variable Expression: 0: signed int
2269--- results are
2270        lvalue signed int
2271
2272converting lvalue signed int
2273 to signed int
2274cost is( 0, 0, 0 )
2275Case +++++++++++++
2276formals are:
2277        signed int
2278        signed int
2279actuals are:
2280                  Variable Expression: a: signed int
2281
2282                  Variable Expression: 0: signed int
2283
2284bindings are:
2285cost of conversion is:( 0, 0, 0 )
2286actual expression:
2287        Variable Expression: a: signed int
2288--- results are
2289        lvalue signed int
2290
2291converting lvalue signed int
2292 to float
2293cost is( 0, 0, 5 )
2294actual expression:
2295        Variable Expression: 0: signed int
2296--- results are
2297        lvalue signed int
2298
2299converting lvalue signed int
2300 to float
2301cost is( 0, 0, 5 )
2302Case +++++++++++++
2303formals are:
2304        float
2305        float
2306actuals 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
2319bindings are:
2320cost of conversion is:( 0, 0, 10 )
2321alternatives before prune:
2322Cost ( 0, 0, 0 ): Application of
2323  Variable Expression: ?!=?: function
2324      with parameters
2325        signed int
2326        signed int
2327      returning
2328        signed int
2329
2330to arguments
2331      Variable Expression: a: signed int
2332
2333      Variable Expression: 0: signed int
2334
2335(types:
2336    signed int
2337)
2338Environment:
2339
2340Cost ( 0, 0, 10 ): Application of
2341  Variable Expression: ?!=?: function
2342      with parameters
2343        float
2344        float
2345      returning
2346        signed int
2347
2348to 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)
2364Environment:
2365
2366there are 1 alternatives before elimination
2367there are 1 alternatives after elimination
2368alternatives before prune:
2369Cost ( 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
2384to:
2385  signed int
2386(types:
2387    signed int
2388)
2389Environment:
2390
2391there are 1 alternatives before elimination
2392there are 1 alternatives after elimination
2393nameExpr is ?!=?
2394decl is ?!=?: function
2395  with parameters
2396    float
2397    float
2398  returning
2399    signed int
2400
2401newExpr is Variable Expression: ?!=?: function
2402    with parameters
2403      float
2404      float
2405    returning
2406      signed int
2407
2408
2409decl is ?!=?: function
2410  with parameters
2411    signed int
2412    signed int
2413  returning
2414    signed int
2415
2416newExpr is Variable Expression: ?!=?: function
2417    with parameters
2418      signed int
2419      signed int
2420    returning
2421      signed int
2422
2423
2424alternatives before prune:
2425Cost ( 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)
2441Environment:
2442
2443Cost ( 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)
2459Environment:
2460
2461there are 2 alternatives before elimination
2462there are 2 alternatives after elimination
2463nameExpr is b
2464decl is b: signed int
2465newExpr is Variable Expression: b: signed int
2466
2467alternatives before prune:
2468Cost ( 0, 0, 0 ): Variable Expression: b: signed int
2469(types:
2470    lvalue signed int
2471)
2472Environment:
2473
2474there are 1 alternatives before elimination
2475there are 1 alternatives after elimination
2476findSubExprs
2477Cost ( 0, 0, 0 ): Variable Expression: b: signed int
2478(types:
2479    lvalue signed int
2480)
2481Environment:
2482
2483nameExpr is 0
2484decl is 0: signed int
2485newExpr is Variable Expression: 0: signed int
2486
2487alternatives before prune:
2488Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
2489(types:
2490    lvalue signed int
2491)
2492Environment:
2493
2494there are 1 alternatives before elimination
2495there are 1 alternatives after elimination
2496findSubExprs
2497Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
2498(types:
2499    lvalue signed int
2500)
2501Environment:
2502
2503working 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:
2521formal type is signed int
2522actual type is lvalue signed int
2523formal type is signed int
2524actual type is lvalue signed int
2525need 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===
2540working 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:
2558formal type is float
2559actual type is lvalue signed int
2560formal type is float
2561actual type is lvalue signed int
2562need 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===
2577actual expression:
2578        Variable Expression: b: signed int
2579--- results are
2580        lvalue signed int
2581
2582converting lvalue signed int
2583 to signed int
2584cost is( 0, 0, 0 )
2585actual expression:
2586        Variable Expression: 0: signed int
2587--- results are
2588        lvalue signed int
2589
2590converting lvalue signed int
2591 to signed int
2592cost is( 0, 0, 0 )
2593Case +++++++++++++
2594formals are:
2595        signed int
2596        signed int
2597actuals are:
2598                  Variable Expression: b: signed int
2599
2600                  Variable Expression: 0: signed int
2601
2602bindings are:
2603cost of conversion is:( 0, 0, 0 )
2604actual expression:
2605        Variable Expression: b: signed int
2606--- results are
2607        lvalue signed int
2608
2609converting lvalue signed int
2610 to float
2611cost is( 0, 0, 5 )
2612actual expression:
2613        Variable Expression: 0: signed int
2614--- results are
2615        lvalue signed int
2616
2617converting lvalue signed int
2618 to float
2619cost is( 0, 0, 5 )
2620Case +++++++++++++
2621formals are:
2622        float
2623        float
2624actuals 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
2637bindings are:
2638cost of conversion is:( 0, 0, 10 )
2639alternatives before prune:
2640Cost ( 0, 0, 0 ): Application of
2641  Variable Expression: ?!=?: function
2642      with parameters
2643        signed int
2644        signed int
2645      returning
2646        signed int
2647
2648to arguments
2649      Variable Expression: b: signed int
2650
2651      Variable Expression: 0: signed int
2652
2653(types:
2654    signed int
2655)
2656Environment:
2657
2658Cost ( 0, 0, 10 ): Application of
2659  Variable Expression: ?!=?: function
2660      with parameters
2661        float
2662        float
2663      returning
2664        signed int
2665
2666to 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)
2682Environment:
2683
2684there are 1 alternatives before elimination
2685there are 1 alternatives after elimination
2686alternatives before prune:
2687Cost ( 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
2702to:
2703  signed int
2704(types:
2705    signed int
2706)
2707Environment:
2708
2709there are 1 alternatives before elimination
2710there are 1 alternatives after elimination
2711alternatives before prune:
2712Cost ( 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
2727to:
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
2744to:
2745  signed int
2746
2747(types:
2748    signed int
2749)
2750Environment:
2751
2752there are 1 alternatives before elimination
2753there are 1 alternatives after elimination
2754findSubExprs
2755Cost ( 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
2770to:
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
2787to:
2788  signed int
2789
2790(types:
2791    signed int
2792)
2793Environment:
2794
2795working 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:
2811formal type is signed int
2812actual type is signed int
2813need 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===
2828working 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:
2844formal type is float
2845actual type is signed int
2846need 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===
2861actual 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
2877to:
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
2894to:
2895  signed int
2896
2897--- results are
2898        signed int
2899
2900converting signed int
2901 to signed int
2902cost is( 0, 0, 0 )
2903Case +++++++++++++
2904formals are:
2905        signed int
2906actuals 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
2922to:
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
2939to:
2940  signed int
2941
2942
2943bindings are:
2944cost of conversion is:( 0, 0, 0 )
2945actual 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
2961to:
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
2978to:
2979  signed int
2980
2981--- results are
2982        signed int
2983
2984converting signed int
2985 to float
2986cost is( 0, 0, 5 )
2987Case +++++++++++++
2988formals are:
2989        float
2990actuals 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
3007to:
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
3024to:
3025  signed int
3026
3027
3028          to:
3029            float
3030
3031bindings are:
3032cost of conversion is:( 0, 0, 5 )
3033alternatives before prune:
3034Cost ( 0, 0, 0 ): Application of
3035  Variable Expression: g: function
3036      with parameters
3037        signed int
3038      returning
3039        nothing
3040
3041to 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
3057to:
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
3074to:
3075  signed int
3076
3077
3078(types:
3079)
3080Environment:
3081
3082Cost ( 0, 0, 5 ): Application of
3083  Variable Expression: g: function
3084      with parameters
3085        float
3086      returning
3087        nothing
3088
3089to 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
3106to:
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
3123to:
3124  signed int
3125
3126
3127    to:
3128      float
3129
3130(types:
3131)
3132Environment:
3133
3134there are 1 alternatives before elimination
3135there are 1 alternatives after elimination
3136alternatives before prune:
3137Cost ( 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
3161to:
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
3178to:
3179  signed int
3180
3181
3182
3183to:
3184  nothing
3185(types:
3186)
3187Environment:
3188
3189there are 1 alternatives before elimination
3190there are 1 alternatives after elimination
3191int ___operator_notequal__Fi_ii_(int , int );
3192int ___operator_notequal__Fi_ff_(float , float );
3193int ___constant_zero__i;
3194void __g__F_f_(float );
3195void __g__F_i_(int );
3196void __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.