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

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

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