Context Navigation

source: dev/trunk/abdev/BasicCompiler_Common/NumOpe_GetType.cpp@ 193

Last change on this file since 193 was 193, checked in by dai_9181, 17 years ago

File size: 21.1 KB

Line
1	#include <jenga/include/smoothie/Smoothie.h>
2	#include <jenga/include/smoothie/LexicalAnalysis.h>
3
4	#include <Compiler.h>
5
6	#include "common.h"
7
8
9	int MakeWholeType(int size,int bSigned){
10	switch(size){
11	case 1:
12	if(bSigned) return DEF_SBYTE;
13	else return DEF_BYTE;
14	break;
15	case 2:
16	if(bSigned) return DEF_INTEGER;
17	else return DEF_WORD;
18	break;
19	case 4:
20	if(bSigned) return DEF_LONG;
21	else return DEF_DWORD;
22	break;
23	case 8:
24	if(bSigned) return DEF_INT64;
25	else return DEF_QWORD;
26	break;
27	}
28	return 0;
29	}
30
31	int AutoBigCast(int BaseType,int CalcType){
32	int type;
33	type=CalcType;
34
35	if(BaseType==0\|\|BaseType==-1){
36	//ベースタイプが未定のとき
37	return type;
38	}
39
40	if(!IsWholeNumberType(type)){
41	//整数型ではないときは暗黙の変換は必要なし
42	return type;
43	}
44
45	if(BaseType==DEF_OBJECT\|\|BaseType==DEF_STRUCT){
46	//ベースタイプがオブジェクトのときは暗黙の変換は必要なし
47	return type;
48	}
49
50	int BaseTypeSize;
51	BaseTypeSize=GetTypeSize(BaseType,-1);
52
53	if(IsRealNumberType(BaseType)){
54	if(GetTypeSize(CalcType,-1)<4)
55	type=MakeWholeType(4,IsSignedType(CalcType));
56	}
57	else if(BaseTypeSize>GetTypeSize(CalcType,-1)){
58	//要求される型のほうがサイズが大きいとき
59	type=MakeWholeType(BaseTypeSize,IsSignedType(CalcType));
60	}
61
62	if(!type){
63	extern int cp;
64	SetError(300,NULL,cp);
65	}
66
67	return type;
68	}
69
70	BOOL CheckCalcType(int idCalc,int *type,int sp){
71	//演算子の右辺、左辺の型をチェック
72	extern int cp;
73
74	//演算子名を取得
75	char temporary[255];
76	GetCalcName(idCalc,temporary);
77
78	switch(idCalc){
79
80	/////////////////////////////////////
81	// 実数に対する論理演算はエラー
82	/////////////////////////////////////
83
84	case CALC_XOR:
85	case CALC_OR:
86	case CALC_AND:
87	if(IsRealNumberType(type[sp-2])\|\|IsRealNumberType(type[sp-1])){
88	//いずれかの項が実数のとき
89	SetError(45,temporary,cp);
90	return 0;
91	}
92
93	//As以外の演算子に型名が指定されていないかをチェック
94	if((type[sp-2]&FLAG_CAST)\|\|(type[sp-1]&FLAG_CAST)){
95	SetError(48,temporary,cp);
96	return 0;
97	}
98	break;
99
100	case CALC_NOT:
101	if(IsRealNumberType(type[sp-1])){
102	//実数のとき
103	SetError(45,temporary,cp);
104	return 0;
105	}
106
107	//As以外の演算子に型名が指定されていないかをチェック
108	if(type[sp-1]&FLAG_CAST){
109	SetError(48,temporary,cp);
110	return 0;
111	}
112	break;
113
114
115
116	/////////////////////////////////////
117	// 比較演算はチェック項目なし
118	/////////////////////////////////////
119
120	case CALC_PE:
121	case CALC_QE:
122	case CALC_NOTEQUAL:
123	case CALC_EQUAL:
124	case CALC_P:
125	case CALC_Q:
126	//As以外の演算子に型名が指定されていないかをチェック
127	if((type[sp-2]&FLAG_CAST)\|\|(type[sp-1]&FLAG_CAST)){
128	SetError(48,temporary,cp);
129	return 0;
130	}
131	break;
132
133
134
135	/////////////////////////////////////
136	// 算術演算をチェック
137	/////////////////////////////////////
138
139	case CALC_ADDITION:
140	case CALC_SUBTRACTION:
141	case CALC_PRODUCT:
142	case CALC_QUOTIENT:
143	case CALC_POWER:
144	//As以外の演算子に型名が指定されていないかをチェック
145	if((type[sp-2]&FLAG_CAST)\|\|(type[sp-1]&FLAG_CAST)){
146	SetError(48,temporary,cp);
147	return 0;
148	}
149	break;
150
151	case CALC_SHL:
152	case CALC_SHR:
153	case CALC_MOD:
154	case CALC_INTQUOTIENT:
155	if(IsRealNumberType(type[sp-2])\|\|IsRealNumberType(type[sp-1])){
156	//いずれかの項が実数のとき
157	SetError(45,temporary,cp);
158	return 0;
159	}
160
161	//As以外の演算子に型名が指定されていないかをチェック
162	if((type[sp-2]&FLAG_CAST)\|\|(type[sp-1]&FLAG_CAST)){
163	SetError(48,temporary,cp);
164	return 0;
165	}
166	break;
167
168	case CALC_AS:
169	if((type[sp-1]&FLAG_CAST)==0){
170	//型名が指定されていないときはエラー
171	SetError(47,NULL,cp);
172	return 0;
173	}
174	break;
175
176	case CALC_BYVAL:
177	if(type[sp-1]&FLAG_CAST){
178	//型名が指定されていないときはエラー
179	SetError(47,NULL,cp);
180	return 0;
181	}
182	break;
183
184	case CALC_MINUSMARK:
185	//As以外の演算子に型名が指定されていないかをチェック
186	if(type[sp-1]&FLAG_CAST){
187	SetError(48,temporary,cp);
188	return 0;
189	}
190	break;
191	}
192	return 1;
193	}
194
195	int GetReturnType_OperatorProc(int idCalc,const Type &baseType,int type,LONG_PTR index_stack,int &sp){
196	//オーバーロードされたオペレータ関数の戻り値を取得
197	CClass *pobj_c;
198	pobj_c=(CClass *)index_stack[sp-2];
199
200	std::vector<UserProc *> subs;
201	pobj_c->GetMethods().Enum( idCalc, subs );
202	if( subs.size() == 0 ){
203	return 0;
204	}
205
206
207	//項の数
208	BOOL bTwoTerm=1;
209	if(idCalc==CALC_AS) bTwoTerm=0;
210
211
212
213	/////////////////////////////////////////////
214	// オーバーロード解決用のパラメータを設定
215	/////////////////////////////////////////////
216
217
218	//_System_LocalThis
219	Parameters params;
220
221	if(bTwoTerm){
222	params.push_back( new Parameter( "", Type( type[sp-1], index_stack[sp-1] ) ) );
223	}
224
225
226	//オーバーロードを解決
227	char temporary[255];
228	if(idCalc==CALC_EQUAL) lstrcpy(temporary,"==");
229	else GetCalcName(idCalc,temporary);
230	UserProc *pUserProc = OverloadSolution( temporary, subs, params, baseType );
231
232	if(bTwoTerm){
233	delete params[0];
234	}
235
236	if(!pUserProc){
237	return 0;
238	}
239	else{
240	//オーバーロードされていないが、パラメータ個数が一致しないとき
241	if(params.size()!=pUserProc->Params().size()){
242	return 0;
243	}
244	}
245
246	sp--;
247	type[sp-1]=pUserProc->ReturnType().GetBasicType();
248	index_stack[sp-1]=pUserProc->ReturnType().GetIndex();
249
250	return 1;
251	}
252
253	bool Operator_New_GetType(const char *Parameter,const Type &baseType, Type &resultType ){
254	char TypeName[VN_SIZE],CreateParameter[VN_SIZE],objectSizeStr[VN_SIZE];
255	int i,i2;
256
257	i=0;
258
259	if(Parameter[0]=='['){
260	i=GetStringInBracket(objectSizeStr,Parameter);
261
262	SlideString(objectSizeStr+1,-1);
263	objectSizeStr[i-2]=0;
264	}
265	else objectSizeStr[0]=0;
266
267	for(i2=0;;i++,i2++){
268	if(Parameter[i]=='('){
269	TypeName[i2]=0;
270
271	//コンストラクタに渡すパラメータを取得
272	i2=GetStringInPare(CreateParameter,Parameter+i);
273	RemoveStringPare(CreateParameter);
274	i+=i2;
275	if(Parameter[i]!='\0'){
276	SetError(42,NULL,cp);
277	return false;
278	}
279	break;
280	}
281	TypeName[i2]=Parameter[i];
282	if(Parameter[i]=='\0'){
283	CreateParameter[0]=0;
284	break;
285	}
286	}
287
288	if( !Compiler::StringToType( TypeName, resultType ) ){
289	return false;
290	}
291
292	if( baseType.IsObject() ){
293	resultType.SetBasicType( DEF_OBJECT );
294	}
295	else{
296	resultType.SetBasicType( DEF_PTR_OBJECT );
297	}
298	return true;
299	}
300
301	bool GetTermType( const char term, Type &resultType, bool &isLiteral, bool pIsClassName ){
302	char parameter[VN_SIZE];
303
304	// Withを解決
305	char termFull[VN_SIZE];
306	if(term[0]=='.'){
307	GetWithName(termFull);
308	lstrcat(termFull,term);
309	}
310	else lstrcpy(termFull,term);
311
312	char termLeft[VN_SIZE];
313	lstrcpy(termLeft,termFull);
314
315	// パース
316	char member[VN_SIZE];
317	CClass::RefType refType;
318	if( CClass::SplitName( termFull, termLeft, member, refType ) ){
319	///////////////////////////////////////////////////////////////////
320	// オブジェクトとメンバに分解できるとき
321	// termLeft.member
322	///////////////////////////////////////////////////////////////////
323
324	isLiteral = false;
325
326	// オブジェクト側の型を取得
327	bool isClassName = false;
328	Type leftType;
329	if( GetTermType( termLeft, leftType, isLiteral, &isClassName ) ){
330	if( isClassName == false && compiler.GetMeta().GetBlittableTypes().IsExist( leftType ) ){
331	// 左側のオブジェクト部分がBlittable型のとき
332
333	char temporary[VN_SIZE];
334	lstrcpy( temporary, termLeft );
335	sprintf( termLeft, "%s(%s)",
336	compiler.GetMeta().GetBlittableTypes().Find( leftType ).GetCreateStaticMethodFullName().c_str(),
337	temporary );
338
339	if( !GetTermType( termLeft, leftType, isLiteral, &isClassName ) ){
340	goto globalArea;
341	}
342	}
343	}
344	else{
345	goto globalArea;
346	}
347
348	if( isClassName ){
349	// 静的メンバ/メソッドの場合
350	goto globalArea;
351	}
352
353	if( !leftType.HasMember() ){
354	// メンバを持たない型の場合
355	return false;
356	}
357
358	const CClass &objClass = leftType.GetClass();
359
360
361	///////////////////////////////////////////////////////////////////
362	// メンバを検索
363	///////////////////////////////////////////////////////////////////
364	if( GetMemberType( objClass, member, resultType, 0, false ) ){
365	// メンバが見つかったとき
366	return true;
367	}
368
369
370	///////////////////////////////////////////////////////////////////
371	// 動的メソッドを検索
372	///////////////////////////////////////////////////////////////////
373	vector<UserProc *> userProcs;
374
375	char methodName[VN_SIZE] ,lpPtrOffset[VN_SIZE];
376	lstrcpy( methodName, member );
377	GetVarFormatString(methodName,parameter,lpPtrOffset,member,refType);
378
379	objClass.GetMethods().Enum( methodName, userProcs );
380	UserProc *pUserProc;
381	if(userProcs.size()){
382	//オーバーロードを解決
383	pUserProc=OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);
384
385	if( pUserProc ){
386	resultType = pUserProc->ReturnType();
387	return true;
388	}
389	}
390
391	return false;
392	}
393
394
395	//////////////////////////////////////////////
396	// クラス名かどうかをチェック（静的メンバ用）
397	//////////////////////////////////////////////
398
399	if( pIsClassName ){
400	if( compiler.GetMeta().GetClasses().Find( termFull ) ){
401	*pIsClassName = true;
402	return true;
403	}
404	}
405
406
407	/////////////////////////////////////////////////////////////////
408	// グローバル属性
409	/////////////////////////////////////////////////////////////////
410	globalArea:
411
412
413	if(lstrcmpi(termFull,"This")==0){
414	//Thisオブジェクト
415	resultType.SetType( DEF_OBJECT, Smoothie::Temp::pCompilingClass );
416	isLiteral = false;
417	return true;
418	}
419
420
421	//////////////////////////////////////
422	// 関数（DLL、ユーザー定義、組み込み）
423	//////////////////////////////////////
424	char procName[VN_SIZE];
425	char temporary[8192];
426
427	int i2=GetCallProcName(termFull,procName);
428	if(termFull[i2]=='('){
429	int i4=GetStringInPare_RemovePare(parameter,termFull+i2+1);
430
431	void *pProc;
432	int idProc=GetProc(procName,(void **)&pProc);
433
434	if(idProc){
435	//閉じカッコ")"に続く文字がNULLでないとき
436	if(termFull[i2+1+i4+1]!='\0'){
437	SetError(42,NULL,cp);
438	}
439
440
441	////////////////
442	// 呼び出し
443	////////////////
444
445	if( !CallProc(idProc,pProc,procName,parameter, resultType, false ) ){
446	return false;
447	}
448	if( resultType.IsNull() ){
449	//戻り値が存在しないとき
450	return false;
451	}
452
453	isLiteral = false;
454
455	return true;
456	}
457	else if(GetConstCalcBuffer(procName,parameter,temporary)){
458	/////////////////////////
459	// マクロ関数
460	/////////////////////////
461
462	//閉じカッコ")"に続く文字がNULLでないときはエラーにする
463	if(termFull[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
464
465	//マクロ関数の場合
466	if( !NumOpe_GetType(temporary,Type(),resultType) ){
467	return false;
468	}
469
470	if( !IS_LITERAL( resultType.GetIndex() ) ){
471	//リテラル値ではなかったとき
472	isLiteral = false;
473	}
474
475	return true;
476	}
477	}
478
479
480	////////////////////////////////
481	// インデクサ（getアクセサ）
482	////////////////////////////////
483
484	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
485	GetArrayElement(termFull,VarName,ArrayElements);
486	if(ArrayElements[0]){
487	GetVarType(VarName,resultType,false);
488	if( resultType.IsObject() ){
489	if( !GetReturnTypeOfIndexerGetterProc( resultType.GetClass(),resultType) ){
490	SetError(1,NULL,cp);
491	return false;
492	}
493
494	isLiteral = false;
495
496	return true;
497	}
498	}
499
500
501	////////////////////////////////
502	// 変数
503	////////////////////////////////
504
505	if( GetVarType( termFull, resultType, false ) ){
506	if( resultType.GetBasicType() & FLAG_PTR ){
507	//配列ポインタ
508	resultType.SetBasicType( GetPtrType( resultType.GetBasicType()^FLAG_PTR ) );
509	}
510
511	isLiteral = false;
512
513	return true;
514	}
515
516
517	/////////////////////////////////
518	// プロパティ用のメソッド
519	/////////////////////////////////
520
521	//配列要素を排除
522	GetArrayElement(termFull,VarName,ArrayElements);
523
524	if(GetSubHash(VarName,0)){
525	GetReturnTypeOfPropertyMethod(termFull,NULL,resultType);
526
527	isLiteral = false;
528
529	return true;
530	}
531
532
533	return false;
534	}
535
536	bool NumOpe_GetType( const char *expression, const Type &baseType, Type &resultType ){
537	extern int cp;
538	int i,i3;
539
540	if(expression[0]=='\0'){
541	SetError(1,NULL,cp);
542	return false;
543	}
544
545	if(expression[0]==1&& expression[1]==ESC_NEW ){
546	//New演算子（オブジェクト生成）
547	return Operator_New_GetType(expression+2,baseType, resultType );
548	}
549
550	if( expression[0] == '[' ){
551	if( !baseType.IsPointer() ){
552	SetError(1,NULL,cp);
553	return false;
554	}
555
556	resultType = baseType;
557	return true;
558	}
559
560
561	/////////////////////////////////
562	// 式要素を逆ポーランド式で取得
563	/////////////////////////////////
564
565	char *values[255];
566	long calc[255];
567	long stack[255];
568	int pnum;
569	if(!GetNumOpeElements(expression,&pnum,values,calc,stack)){
570	for(i=0;i<pnum;i++){
571	if(values[i]) HeapDefaultFree(values[i]);
572	}
573	return false;
574	}
575
576
577
578	////////////////////////////////
579	// 演算部分のコード生成を開始
580	////////////////////////////////
581
582	BOOL bError;
583	bError=0;
584
585	//リテラル値のみの計算かどうかを判別するためのフラグ
586	BOOL bLiteralCalculation=1;
587
588	int sp;
589	int type_stack[255];
590	LONG_PTR index_stack[255];
591	bool isNothing_stack[255];
592	_int64 i64data;
593	int idCalc;
594	for(i=0,sp=0;i<pnum;i++){
595	idCalc=calc[i]%100;
596
597	if(idCalc){
598	if(type_stack[sp-2]==DEF_OBJECT){
599	if( idCalc == CALC_AS
600	&& type_stack[sp-1] == ( DEF_OBJECT \| FLAG_CAST )
601	&& index_stack[sp-1] == index_stack[sp-2]
602	\|\| isNothing_stack[sp-2] ){
603	// 同一の型、またはNothingに対するAsはAs演算子を呼び出さない
604	}
605	else if( idCalc == CALC_AS
606	&& type_stack[sp-1] == ( DEF_OBJECT \| FLAG_CAST )
607	&& ( ((CClass )index_stack[sp-1])->IsEqualsOrSubClass( (CClass )index_stack[sp-2] ) \|\| ((CClass )index_stack[sp-2])->IsEqualsOrSubClass( (CClass )index_stack[sp-1] )
608	)){
609	// ダウンキャストを許可する
610	}
611	else if( idCalc == CALC_AS ){
612	// NumOpe_GetTypeではすべてのキャストを許可する
613	}
614	else{
615	//オーバーロードされたオペレータを呼び出す
616	if(!GetReturnType_OperatorProc(idCalc,baseType,type_stack,index_stack,sp)){
617	goto error;
618	}
619
620	continue;
621	}
622	}
623
624	if(!CheckCalcType(idCalc,type_stack,sp)) goto error;
625	}
626
627	switch(idCalc){
628	//数値
629	case 0:
630	index_stack[sp]=-1;
631	isNothing_stack[sp] = false;
632
633	char *term;
634	term = values[i];
635
636	if( calc[i+1]%100 == CALC_AS ){
637	// As演算子の右辺値
638	//型名
639	if( Compiler::StringToType( term, resultType ) ){
640
641	if( resultType.IsObject() ){
642	if( resultType.GetClass().IsBlittableType() ){
643	// Blittable型のときは基本型として扱う
644	// ※ただし、コンパイル中のメソッドがBlittable型クラスに属していないこと
645	if( UserProc::IsLocalAreaCompiling()
646	&& UserProc::CompilingUserProc().HasParentClass()
647	&& UserProc::CompilingUserProc().GetParentClass().IsBlittableType() )
648	{
649	// コンパイル中のメソッドがBlittable型クラスに属している
650	}
651	else{
652	resultType = resultType.GetClass().GetBlittableType();
653	}
654	}
655	}
656
657	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_CAST );
658	}
659	else{
660	SetError(3, term, cp );
661	goto error;
662	}
663
664	type_stack[sp] = resultType.GetBasicType();
665	index_stack[sp] = resultType.GetIndex();
666	sp++;
667
668	break;
669	}
670
671	if(term[0]=='\"'){
672	StrLiteral:
673
674	if( baseType.IsObject() \|\| baseType.IsNull() ){
675	//要求タイプがオブジェクト、または未定のとき
676	type_stack[sp]=DEF_OBJECT;
677	index_stack[sp]=(LONG_PTR)compiler.GetMeta().GetClasses().GetStringClassPtr();
678	bLiteralCalculation=0;
679
680	sp++;
681	break;
682	}
683
684	type_stack[sp]=typeOfPtrChar;
685	bLiteralCalculation=0;
686	}
687	else if((term[0]=='e'\|\|term[0]=='E')&&
688	(term[1]=='x'\|\|term[1]=='X')&&
689	term[2]=='\"'){
690	//拡張版リテラル文字列（エスケープシーケンス可能）
691	goto StrLiteral;
692	}
693	else if(IsVariableTopChar(term[0])\|\|
694	term[0]=='*'\|\|
695	(term[0]=='.'&&IsVariableTopChar(term[1]))){
696	//////////////////
697	// 何らかの識別子
698
699	bool isLiteral = true;
700	if( GetTermType( term, resultType, isLiteral ) ){
701	type_stack[sp] = resultType.GetBasicType();
702	index_stack[sp] = resultType.GetIndex();
703
704	if( !isLiteral ){
705	bLiteralCalculation=0;
706	}
707
708	sp++;
709	break;
710	}
711
712
713	// Nothing
714	if( lstrcmp( term, "Nothing" ) == 0 ){
715	isNothing_stack[sp] = true;
716
717	type_stack[sp] = DEF_OBJECT;
718	if( baseType.IsObject() ){
719	index_stack[sp] = baseType.GetIndex();
720	}
721	else{
722	index_stack[sp] = (LONG_PTR)compiler.GetMeta().GetClasses().GetObjectClassPtr();
723	}
724	bLiteralCalculation = 0;
725	sp++;
726	break;
727	}
728
729
730	//////////////
731	// 定数の場合
732	//////////////
733
734	i3 = CDBConst::obj.GetBasicType(term);
735	if(i3){
736	if( CDBConst::obj.IsStringPtr( term ) ){
737	//リテラル文字列
738	goto StrLiteral;
739	}
740
741	type_stack[sp]=i3;
742	if(IsRealNumberType(i3)){
743	//実数
744	goto Literal;
745	}
746	else if(IsWholeNumberType(i3)){
747	//整数
748	goto Literal;
749	}
750	else if(Is64Type(i3)){
751	//64ビット整数値
752	goto Literal;
753	}
754	else{
755	SetError(1,NULL,0);
756	goto error;
757	}
758	}
759
760
761	/////////////////////////////////
762	// プロパティ用のメソッド
763	/////////////////////////////////
764
765	//配列要素を排除
766	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
767	GetArrayElement(term,VarName,ArrayElements);
768
769	if(GetSubHash(VarName,0)){
770	SetError();
771	Type tempType;
772	GetReturnTypeOfPropertyMethod(term,NULL,tempType);
773
774	//大きな型への暗黙の変換
775	type_stack[sp]=tempType.GetBasicType();
776
777	index_stack[sp]=tempType.GetIndex();
778	bLiteralCalculation=0;
779
780	sp++;
781	break;
782	}
783
784
785
786	//該当する識別子が見当たらないときはエラー扱いにする
787	bError=1;
788	SetError(3,term,cp);
789	type_stack[sp]=DEF_DOUBLE;
790	}
791	else{
792	//リテラル値
793	int base_type = 0;
794	if( !baseType.IsNull() ) base_type = baseType.GetBasicType();
795	type_stack[sp]=GetLiteralValue(term,&i64data,base_type);
796	Literal:
797	if((long)i64data==0&&index_stack[sp]==-1) index_stack[sp]=LITERAL_NULL;
798	}
799
800	sp++;
801	break;
802
803	//論理演算子
804	case CALC_XOR:
805	case CALC_OR:
806	case CALC_AND:
807	sp--;
808	type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
809	break;
810	case CALC_NOT:
811	//values[sp-1]=Not values[sp-1]
812	//NOT演算子
813	break;
814
815	//比較演算子
816	case CALC_PE: //values[sp-2] <= values[sp-1]
817	case CALC_QE: //values[sp-2] >= values[sp-1]
818	case CALC_P: //values[sp-2] < values[sp-1]
819	case CALC_Q: //values[sp-2] > values[sp-1]
820	case CALC_NOTEQUAL: //values[sp-2] <> values[sp-1]
821	case CALC_EQUAL: //values[sp-2] = values[sp-1]
822	sp--;
823	type_stack[sp-1]=DEF_LONG;
824	break;
825
826	//ビットシフト
827	case CALC_SHL: //values[sp-2] << values[sp-1]
828	case CALC_SHR: //values[sp-2] >> values[sp-1]
829	sp--;
830	break;
831
832	//算術演算
833	case CALC_ADDITION:
834	case CALC_SUBTRACTION:
835	case CALC_PRODUCT:
836	sp--;
837	type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
838	break;
839	case CALC_MOD:
840	//values[sp-2]%=values[sp-1]
841	//剰余演算
842	sp--;
843	type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
844	break;
845	case CALC_QUOTIENT:
846	//values[sp-2]/=values[sp-1];
847	//除算
848	sp--;
849	type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
850	break;
851	case CALC_INTQUOTIENT:
852	//values[sp-2]/=values[sp-1]
853	//整数除算
854	sp--;
855	type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
856	break;
857	case CALC_MINUSMARK:
858	//values[sp-1]=-values[sp-1]
859	//符号反転
860	break;
861	case CALC_POWER:
862	//べき乗演算（浮動小数点演算のみ）
863	sp--;
864	//未完成
865	break;
866	case CALC_AS:
867	//キャスト
868	type_stack[sp-2]=type_stack[sp-1]&(~FLAG_CAST);
869	index_stack[sp-2]=index_stack[sp-1];
870
871	sp--;
872	break;
873
874	case CALC_BYVAL:
875	//ポインタ型→参照型
876	if( PTR_LEVEL( type_stack[sp-1] ) <= 0 ){
877	//ポインタ型ではないとき
878	SetError( 3, NULL, cp );
879	goto error;
880	}
881
882	type_stack[sp-1] = PTR_LEVEL_DOWN( type_stack[sp-1] );
883	break;
884	}
885	}
886
887	if(bError) goto error;
888
889	if(sp!=1){
890	SetError(1,NULL,cp);
891	goto error;
892	}
893
894	if(bLiteralCalculation){
895	//右辺値が数値の定数式の場合
896	int base_type = 0;
897	if( !baseType.IsNull() ) base_type = baseType.GetBasicType();
898	Type tempType;
899	StaticCalculation(true, expression,base_type,&i64data,tempType);
900
901	type_stack[0]=tempType.GetBasicType();
902	index_stack[0]=tempType.GetIndex();
903	}
904	else{
905	//右辺値が数値の定数式ではないとき
906	if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
907	}
908
909	resultType.SetType( type_stack[0], index_stack[0] );
910
911	bool isSuccessful = true;
912	goto finish;
913
914
915	//////////////////
916	// エラー処理
917	//////////////////
918
919	error:
920	isSuccessful = false;
921	goto finish;
922
923
924	finish:
925	for(i=0;i<pnum;i++){
926	if(values[i]) HeapDefaultFree(values[i]);
927	}
928	return isSuccessful;
929	}

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

Download in other formats: