source: dev/BasicCompiler_Common/NumOpe_GetType.cpp@ 129

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

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