Context Navigation

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

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

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

Download in other formats: