Context Navigation

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

Last change on this file since 290 was 290, checked in by dai_9181, 17 years ago
ジェネリクスのベースを実装
File size: 22.2 KB

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

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

Download in other formats: