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

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

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