Context Navigation

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

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

File size: 22.6 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 GetMemberTermType( const Type &leftType, const Type &baseType, Type &resultType, const char termFull, const char termLeft, const char *member )
304	{
305	////////////////////////////////
306	// インデクサ（getアクセサ）
307	////////////////////////////////
308
309	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
310	GetArrayElement(member,VarName,ArrayElements);
311	if(ArrayElements[0]){
312	Type classType;
313	GetMemberType( leftType, VarName, classType, 0, false );
314	if( classType.IsObject() ){
315	if( !GetReturnTypeOfIndexerGetterProc( classType, resultType ) ){
316	SetError(1,NULL,cp);
317	return false;
318	}
319
320	return true;
321	}
322	}
323
324
325	///////////////////////////////////////////////////////////////////
326	// メンバを検索
327	///////////////////////////////////////////////////////////////////
328	if( GetMemberType( leftType, member, resultType, 0, false ) ){
329	// メンバが見つかったとき
330	return true;
331	}
332
333
334	///////////////////////////////////////////////////////////////////
335	// 動的メソッドを検索
336	///////////////////////////////////////////////////////////////////
337	char methodName[VN_SIZE] ,lpPtrOffset[VN_SIZE], dummy[1];
338	char parameter[VN_SIZE];
339	ReferenceKind refType;
340	lstrcpy( methodName, member );
341	GetVarFormatString(methodName,parameter,lpPtrOffset,dummy,refType);
342
343	vector<const UserProc *> userProcs;
344	leftType.GetClass().GetMethods().Enum( methodName, userProcs );
345	if(userProcs.size()){
346	//オーバーロードを解決
347	const UserProc *pUserProc = OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);
348
349	if( pUserProc ){
350	resultType = pUserProc->ReturnType();
351
352	// 型パラメータを解決
353	ResolveFormalGenericTypeParameter( resultType, leftType, pUserProc );
354
355	return true;
356	}
357	}
358
359	return false;
360	}
361
362	bool GetTermType( const char term, const Type &baseType, Type &resultType, bool &isLiteral, bool pIsClassName )
363	{
364	char parameter[VN_SIZE];
365
366	// Withを解決
367	char termFull[VN_SIZE];
368	if(term[0]=='.'){
369	GetWithName(termFull);
370	lstrcat(termFull,term);
371	}
372	else lstrcpy(termFull,term);
373
374	char termLeft[VN_SIZE];
375	lstrcpy(termLeft,termFull);
376
377	// パース
378	char member[VN_SIZE];
379	ReferenceKind refType;
380	if( SplitMemberName( termFull, termLeft, member, refType ) ){
381	///////////////////////////////////////////////////////////////////
382	// オブジェクトとメンバに分解できるとき
383	// termLeft.member
384	///////////////////////////////////////////////////////////////////
385
386	isLiteral = false;
387
388	// オブジェクト側の型を取得
389	bool isClassName = false;
390	Type leftType;
391	if( GetTermType( termLeft, Type(), leftType, isLiteral, &isClassName ) ){
392	if( isClassName == false && compiler.GetObjectModule().meta.GetBlittableTypes().IsExist( leftType ) ){
393	// 左側のオブジェクト部分がBlittable型のとき
394
395	char temporary[VN_SIZE];
396	lstrcpy( temporary, termLeft );
397	sprintf( termLeft, "%s(%s)",
398	compiler.GetObjectModule().meta.GetBlittableTypes().Find( leftType ).GetCreateStaticMethodFullName().c_str(),
399	temporary );
400
401	if( !GetTermType( termLeft, Type(), leftType, isLiteral, &isClassName ) ){
402	goto globalArea;
403	}
404	}
405	}
406	else{
407	goto globalArea;
408	}
409
410	if( isClassName ){
411	// 静的メンバ/メソッドの場合
412	goto globalArea;
413	}
414
415	if( !leftType.HasMember() ){
416	// メンバを持たない型の場合
417	return false;
418	}
419
420	return GetMemberTermType( leftType, baseType, resultType, termFull, termLeft, member );
421	}
422
423
424	//////////////////////////////////////////////
425	// クラス名かどうかをチェック（静的メンバ用）
426	//////////////////////////////////////////////
427
428	if( pIsClassName ){
429	if( compiler.GetObjectModule().meta.GetClasses().Find( termFull ) ){
430	*pIsClassName = true;
431	return true;
432	}
433	}
434
435
436	/////////////////////////////////////////////////////////////////
437	// グローバル属性
438	/////////////////////////////////////////////////////////////////
439	globalArea:
440
441
442	if(lstrcmpi(termFull,"This")==0){
443	//Thisオブジェクト
444	resultType.SetType( DEF_OBJECT, compiler.pCompilingClass );
445	isLiteral = false;
446	return true;
447	}
448
449
450	//////////////////////////////////////
451	// 関数（DLL、ユーザー定義、組み込み）
452	//////////////////////////////////////
453	char procName[VN_SIZE];
454	char temporary[8192];
455
456	int i2=GetCallProcName(termFull,procName);
457	if(termFull[i2]=='('){
458	int i4=GetStringInPare_RemovePare(parameter,termFull+i2+1);
459
460	void *pProc;
461	int idProc=GetProc(procName,(void **)&pProc);
462
463	if(idProc){
464	//閉じカッコ")"に続く文字がNULLでないとき
465	if(termFull[i2+1+i4+1]!='\0'){
466	SetError(42,NULL,cp);
467	}
468
469
470	////////////////
471	// 呼び出し
472	////////////////
473
474	if( !CallProc(idProc,pProc,procName,parameter, baseType, resultType, false ) ){
475	return false;
476	}
477	if( resultType.IsNull() ){
478	//戻り値が存在しないとき
479	return false;
480	}
481
482	isLiteral = false;
483
484	return true;
485	}
486	else
487	{
488	ConstMacro *pConstMacro = compiler.GetObjectModule().meta.GetGlobalConstMacros().Find( procName );
489	if( pConstMacro )
490	{
491	if( pConstMacro->GetCalcBuffer( parameter, temporary ) )
492	{
493	/////////////////////////
494	// マクロ関数
495	/////////////////////////
496
497	//閉じカッコ")"に続く文字がNULLでないときはエラーにする
498	if(termFull[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
499
500	//マクロ関数の場合
501	if( !NumOpe_GetType(temporary,Type(),resultType) ){
502	return false;
503	}
504
505	if( !IS_LITERAL( resultType.GetIndex() ) ){
506	//リテラル値ではなかったとき
507	isLiteral = false;
508	}
509
510	return true;
511	}
512	}
513	}
514	}
515
516
517	////////////////////////////////
518	// インデクサ（getアクセサ）
519	////////////////////////////////
520
521	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
522	GetArrayElement(termFull,VarName,ArrayElements);
523	if(ArrayElements[0]){
524	Type classType;
525	GetVarType(VarName,classType,false);
526	if( classType.IsObject() ){
527	if( !GetReturnTypeOfIndexerGetterProc( classType, resultType ) ){
528	SetError(1,NULL,cp);
529	return false;
530	}
531
532	isLiteral = false;
533
534	return true;
535	}
536	}
537
538
539	////////////////////////////////
540	// 変数
541	////////////////////////////////
542
543	if( GetVarType( termFull, resultType, false ) ){
544	if( resultType.GetBasicType() & FLAG_PTR ){
545	//配列ポインタ
546	resultType.SetBasicType( GetPtrType( resultType.GetBasicType()^FLAG_PTR ) );
547	}
548
549	isLiteral = false;
550
551	return true;
552	}
553
554
555	/////////////////////////////////
556	// プロパティ用のメソッド
557	/////////////////////////////////
558
559	//配列要素を排除
560	GetArrayElement(termFull,VarName,ArrayElements);
561
562	if(GetSubHash(VarName,0)){
563	GetReturnTypeOfPropertyMethod(termFull,NULL,resultType);
564
565	isLiteral = false;
566
567	return true;
568	}
569
570
571	return false;
572	}
573
574	bool NumOpe_GetType( const char expression, const Type &baseType, Type &resultType, bool pIsLiteralCalculation ){
575	extern int cp;
576	int i,i3;
577
578	//リテラル値のみの計算かどうかを判別するためのフラグ
579	bool dummyBool;
580	if( pIsLiteralCalculation == NULL )
581	{
582	pIsLiteralCalculation = &dummyBool;
583	}
584	*pIsLiteralCalculation = true;
585
586	if(expression[0]=='\0'){
587	SetError(1,NULL,cp);
588	return false;
589	}
590
591	if(expression[0]==1&& expression[1]==ESC_NEW ){
592	//New演算子（オブジェクト生成）
593	*pIsLiteralCalculation = false;
594	return Operator_New_GetType(expression+2,baseType, resultType );
595	}
596
597	if( expression[0] == '[' ){
598	if( !baseType.IsPointer() ){
599	SetError(1,NULL,cp);
600	return false;
601	}
602
603	resultType = baseType;
604	return true;
605	}
606
607
608	/////////////////////////////////
609	// 式要素を逆ポーランド式で取得
610	/////////////////////////////////
611
612	char *values[255];
613	long calc[255];
614	long stack[255];
615	int pnum;
616	if(!GetNumOpeElements(expression,&pnum,values,calc,stack)){
617	for(i=0;i<pnum;i++){
618	if(values[i]) HeapDefaultFree(values[i]);
619	}
620	return false;
621	}
622
623
624
625	////////////////////////////////
626	// 演算部分のコード生成を開始
627	////////////////////////////////
628
629	BOOL bError;
630	bError=0;
631
632	int sp;
633	int type_stack[255];
634	LONG_PTR index_stack[255];
635	bool isNothing_stack[255];
636	_int64 i64data;
637	int idCalc;
638	for(i=0,sp=0;i<pnum;i++){
639	idCalc=calc[i]%100;
640
641	if(idCalc){
642	if(type_stack[sp-2]==DEF_OBJECT){
643	if( idCalc == CALC_AS
644	&& type_stack[sp-1] == ( DEF_OBJECT \| FLAG_CAST )
645	&& index_stack[sp-1] == index_stack[sp-2]
646	\|\| isNothing_stack[sp-2] ){
647	// 同一の型、またはNothingに対するAsはAs演算子を呼び出さない
648	}
649	else if( idCalc == CALC_AS
650	&& type_stack[sp-1] == ( DEF_OBJECT \| FLAG_CAST )
651	&& ( ((CClass )index_stack[sp-1])->IsEqualsOrSubClass( (CClass )index_stack[sp-2] ) \|\| ((CClass )index_stack[sp-2])->IsEqualsOrSubClass( (CClass )index_stack[sp-1] )
652	)){
653	// ダウンキャストを許可する
654	}
655	else if( idCalc == CALC_AS ){
656	// NumOpe_GetTypeではすべてのキャストを許可する
657	}
658	else{
659	//オーバーロードされたオペレータを呼び出す
660	if(!GetReturnType_OperatorProc(idCalc,baseType,type_stack,index_stack,sp)){
661	goto error;
662	}
663
664	continue;
665	}
666	}
667
668	if(!CheckCalcType(idCalc,type_stack,sp)) goto error;
669	}
670
671	switch(idCalc){
672	//数値
673	case 0:
674	index_stack[sp]=-1;
675	isNothing_stack[sp] = false;
676
677	char *term;
678	term = values[i];
679
680	if( calc[i+1]%100 == CALC_AS ){
681	// As演算子の右辺値
682	//型名
683	if( compiler.StringToType( term, resultType ) ){
684
685	if( resultType.IsObject() ){
686	if( resultType.GetClass().IsBlittableType() ){
687	// Blittable型のときは基本型として扱う
688	// ※ただし、コンパイル中のメソッドがBlittable型クラスに属していないこと
689	if( UserProc::IsLocalAreaCompiling()
690	&& UserProc::CompilingUserProc().HasParentClass()
691	&& UserProc::CompilingUserProc().GetParentClass().IsBlittableType() )
692	{
693	// コンパイル中のメソッドがBlittable型クラスに属している
694	}
695	else{
696	resultType = resultType.GetClass().GetBlittableType();
697	}
698	}
699	}
700
701	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_CAST );
702	}
703	else{
704	SetError(3, term, cp );
705	goto error;
706	}
707
708	type_stack[sp] = resultType.GetBasicType();
709	index_stack[sp] = resultType.GetIndex();
710	sp++;
711
712	break;
713	}
714
715	if(term[0]=='\"'){
716	StrLiteral:
717
718	if( baseType.IsObject() \|\| baseType.IsNull() ){
719	//要求タイプがオブジェクト、または未定のとき
720	type_stack[sp]=DEF_OBJECT;
721	index_stack[sp]=(LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr();
722	*pIsLiteralCalculation = false;
723
724	sp++;
725	break;
726	}
727
728	type_stack[sp]=typeOfPtrChar;
729	*pIsLiteralCalculation = false;
730	}
731	else if((term[0]=='e'\|\|term[0]=='E')&&
732	(term[1]=='x'\|\|term[1]=='X')&&
733	term[2]=='\"'){
734	//拡張版リテラル文字列（エスケープシーケンス可能）
735	goto StrLiteral;
736	}
737	else if(IsVariableTopChar(term[0])\|\|
738	term[0]=='*'\|\|
739	(term[0]=='.'&&IsVariableTopChar(term[1])))
740	{
741	//////////////////
742	// 何らかの識別子
743
744	bool isLiteral = true;
745	if( GetTermType( term, baseType, resultType, isLiteral ) ){
746	type_stack[sp] = resultType.GetBasicType();
747	index_stack[sp] = resultType.GetIndex();
748
749	if( !isLiteral ){
750	*pIsLiteralCalculation = false;
751	}
752
753	sp++;
754	break;
755	}
756
757
758	// Nothing
759	if( lstrcmp( term, "Nothing" ) == 0 ){
760	isNothing_stack[sp] = true;
761
762	type_stack[sp] = DEF_OBJECT;
763	if( baseType.IsObject() ){
764	index_stack[sp] = baseType.GetIndex();
765	}
766	else{
767	index_stack[sp] = (LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr();
768	}
769	*pIsLiteralCalculation = false;
770	sp++;
771	break;
772	}
773
774
775	//////////////
776	// 定数の場合
777	//////////////
778
779	i3 = compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType(term);
780	if(i3){
781	if( compiler.GetObjectModule().meta.GetGlobalConsts().IsStringPtr( term ) ){
782	//リテラル文字列
783	goto StrLiteral;
784	}
785
786	type_stack[sp]=i3;
787	if(IsRealNumberType(i3)){
788	//実数
789	goto Literal;
790	}
791	else if(IsWholeNumberType(i3)){
792	//整数
793	goto Literal;
794	}
795	else if(Is64Type(i3)){
796	//64ビット整数値
797	goto Literal;
798	}
799	else{
800	SetError(1,NULL,0);
801	goto error;
802	}
803	}
804
805
806	/////////////////////////////////
807	// プロパティ用のメソッド
808	/////////////////////////////////
809
810	//配列要素を排除
811	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
812	GetArrayElement(term,VarName,ArrayElements);
813
814	if(GetSubHash(VarName,0)){
815	SetError();
816	Type tempType;
817	GetReturnTypeOfPropertyMethod(term,NULL,tempType);
818
819	//大きな型への暗黙の変換
820	type_stack[sp]=tempType.GetBasicType();
821
822	index_stack[sp]=tempType.GetIndex();
823	*pIsLiteralCalculation = false;
824
825	sp++;
826	break;
827	}
828
829
830
831	//該当する識別子が見当たらないときはエラー扱いにする
832	bError=1;
833	SetError(3,term,cp);
834	type_stack[sp]=DEF_DOUBLE;
835	}
836	else{
837	//リテラル値
838	int base_type = 0;
839	if( !baseType.IsNull() ) base_type = baseType.GetBasicType();
840	type_stack[sp]=GetLiteralValue(term,&i64data,base_type);
841	Literal:
842	if((long)i64data==0&&index_stack[sp]==-1) index_stack[sp]=LITERAL_NULL;
843	}
844
845	sp++;
846	break;
847
848	//論理演算子
849	case CALC_XOR:
850	case CALC_OR:
851	case CALC_AND:
852	sp--;
853	type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
854	break;
855	case CALC_NOT:
856	//values[sp-1]=Not values[sp-1]
857	//NOT演算子
858	break;
859
860	//比較演算子
861	case CALC_PE: //values[sp-2] <= values[sp-1]
862	case CALC_QE: //values[sp-2] >= values[sp-1]
863	case CALC_P: //values[sp-2] < values[sp-1]
864	case CALC_Q: //values[sp-2] > values[sp-1]
865	case CALC_NOTEQUAL: //values[sp-2] <> values[sp-1]
866	case CALC_EQUAL: //values[sp-2] = values[sp-1]
867	sp--;
868	type_stack[sp-1]=DEF_LONG;
869	break;
870
871	//ビットシフト
872	case CALC_SHL: //values[sp-2] << values[sp-1]
873	case CALC_SHR: //values[sp-2] >> values[sp-1]
874	sp--;
875	break;
876
877	//算術演算
878	case CALC_ADDITION:
879	case CALC_SUBTRACTION:
880	case CALC_PRODUCT:
881	sp--;
882	type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
883	break;
884	case CALC_MOD:
885	//values[sp-2]%=values[sp-1]
886	//剰余演算
887	sp--;
888	type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
889	break;
890	case CALC_QUOTIENT:
891	//values[sp-2]/=values[sp-1];
892	//除算
893	sp--;
894	type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
895	break;
896	case CALC_INTQUOTIENT:
897	//values[sp-2]/=values[sp-1]
898	//整数除算
899	sp--;
900	type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
901	break;
902	case CALC_MINUSMARK:
903	//values[sp-1]=-values[sp-1]
904	//符号反転
905	break;
906	case CALC_POWER:
907	//べき乗演算（浮動小数点演算のみ）
908	sp--;
909	//未完成
910	break;
911	case CALC_AS:
912	//キャスト
913	type_stack[sp-2]=type_stack[sp-1]&(~FLAG_CAST);
914	index_stack[sp-2]=index_stack[sp-1];
915
916	sp--;
917	break;
918
919	case CALC_BYVAL:
920	//ポインタ型→参照型
921	if( PTR_LEVEL( type_stack[sp-1] ) <= 0 ){
922	//ポインタ型ではないとき
923	SetError( 3, NULL, cp );
924	goto error;
925	}
926
927	type_stack[sp-1] = PTR_LEVEL_DOWN( type_stack[sp-1] );
928	break;
929	}
930	}
931
932	if(bError) goto error;
933
934	if(sp!=1){
935	SetError(1,NULL,cp);
936	goto error;
937	}
938
939	if( *pIsLiteralCalculation ){
940	//右辺値が数値の定数式の場合
941	int base_type = 0;
942	if( !baseType.IsNull() ) base_type = baseType.GetBasicType();
943	Type tempType;
944	StaticCalculation(true, expression,base_type,&i64data,tempType);
945
946	type_stack[0]=tempType.GetBasicType();
947	index_stack[0]=tempType.GetIndex();
948	}
949	else{
950	//右辺値が数値の定数式ではないとき
951	if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
952	}
953
954	resultType.SetType( type_stack[0], index_stack[0] );
955
956	bool isSuccessful = true;
957	goto finish;
958
959
960	//////////////////
961	// エラー処理
962	//////////////////
963
964	error:
965	isSuccessful = false;
966	goto finish;
967
968
969	finish:
970	for(i=0;i<pnum;i++){
971	if(values[i]) HeapDefaultFree(values[i]);
972	}
973	return isSuccessful;
974	}

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

Download in other formats: