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

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