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

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