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

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