Context Navigation

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

Visit:

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

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

Rev	Line
[b1d6dd5]	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: