Context Navigation

source: dev/BasicCompiler_Common/NumOpe_GetType.cpp@ 103

Last change on this file since 103 was 103, checked in by dai_9181, 17 years ago
名前空間機能をグローバル変数、定数と列挙型に適用。一部、クラスの静的メンバと名前空間の相性が悪いコードが潜んでいるため、要改修
File size: 19.8 KB

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

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

Download in other formats: