Context Navigation

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

Last change on this file since 412 was 412, checked in by dai_9181, 16 years ago
CClass::GetStaticDefiningStringAsMemberOffsetsメソッドを追加。エラーコード142を追加。
File size: 22.5 KB

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

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

Download in other formats: