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
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
[331]303bool GetTermType( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, bool *pIsClassName )
[292]304{
[97]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];
[206]320 ReferenceKind refType;
321 if( SplitMemberName( termFull, termLeft, member, refType ) ){
[97]322 ///////////////////////////////////////////////////////////////////
323 // オブジェクトとメンバに分解できるとき
324 // termLeft.member
325 ///////////////////////////////////////////////////////////////////
326
327 isLiteral = false;
328
329 // オブジェクト側の型を取得
330 bool isClassName = false;
331 Type leftType;
[331]332 if( GetTermType( termLeft, Type(), leftType, isLiteral, &isClassName ) ){
[265]333 if( isClassName == false && compiler.GetObjectModule().meta.GetBlittableTypes().IsExist( leftType ) ){
[128]334 // 左側のオブジェクト部分がBlittable型のとき
335
336 char temporary[VN_SIZE];
337 lstrcpy( temporary, termLeft );
338 sprintf( termLeft, "%s(%s)",
[265]339 compiler.GetObjectModule().meta.GetBlittableTypes().Find( leftType ).GetCreateStaticMethodFullName().c_str(),
[128]340 temporary );
341
[331]342 if( !GetTermType( termLeft, Type(), leftType, isLiteral, &isClassName ) ){
[128]343 goto globalArea;
344 }
345 }
346 }
347 else{
[103]348 goto globalArea;
[97]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 ///////////////////////////////////////////////////////////////////
[290]365 if( GetMemberType( leftType, member, resultType, 0, false ) ){
[97]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
[206]378 vector<const UserProc *> userProcs;
[290]379 leftType.GetClass().GetMethods().Enum( methodName, userProcs );
[97]380 if(userProcs.size()){
381 //オーバーロードを解決
[206]382 const UserProc *pUserProc = OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);
[97]383
384 if( pUserProc ){
385 resultType = pUserProc->ReturnType();
[290]386
[299]387 // 型パラメータを解決
388 ResolveFormalGenericTypeParameter( resultType, leftType, pUserProc );
[290]389
[97]390 return true;
391 }
392 }
393
394 return false;
395 }
396
397
398 //////////////////////////////////////////////
399 // クラス名かどうかをチェック（静的メンバ用）
400 //////////////////////////////////////////////
401
402 if( pIsClassName ){
[265]403 if( compiler.GetObjectModule().meta.GetClasses().Find( termFull ) ){
[97]404 *pIsClassName = true;
405 return true;
406 }
407 }
408
409
410 /////////////////////////////////////////////////////////////////
411 // グローバル属性
412 /////////////////////////////////////////////////////////////////
413globalArea:
414
415
416 if(lstrcmpi(termFull,"This")==0){
417 //Thisオブジェクト
[206]418 resultType.SetType( DEF_OBJECT, compiler.pCompilingClass );
[98]419 isLiteral = false;
[97]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
[331]448 if( !CallProc(idProc,pProc,procName,parameter, baseType, resultType, false ) ){
[97]449 return false;
450 }
451 if( resultType.IsNull() ){
452 //戻り値が存在しないとき
453 return false;
454 }
455
456 isLiteral = false;
457
458 return true;
459 }
[206]460 else
461 {
[265]462 ConstMacro *pConstMacro = compiler.GetObjectModule().meta.GetGlobalConstMacros().Find( procName );
[206]463 if( pConstMacro )
464 {
465 if( pConstMacro->GetCalcBuffer( parameter, temporary ) )
466 {
467 /////////////////////////
468 // マクロ関数
469 /////////////////////////
[97]470
[206]471 //閉じカッコ")"に続く文字がNULLでないときはエラーにする
472 if(termFull[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
[97]473
[206]474 //マクロ関数の場合
475 if( !NumOpe_GetType(temporary,Type(),resultType) ){
476 return false;
477 }
[97]478
[206]479 if( !IS_LITERAL( resultType.GetIndex() ) ){
480 //リテラル値ではなかったとき
481 isLiteral = false;
482 }
483
484 return true;
485 }
[97]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]){
[292]498 Type classType;
499 GetVarType(VarName,classType,false);
500 if( classType.IsObject() ){
501 if( !GetReturnTypeOfIndexerGetterProc( classType, resultType ) ){
[97]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
[254]548bool NumOpe_GetType( const char *expression, const Type &baseType, Type &resultType, bool *pIsLiteralCalculation ){
[4]549 extern int cp;
[97]550 int i,i3;
[4]551
[254]552 //リテラル値のみの計算かどうかを判別するためのフラグ
553 bool dummyBool;
554 if( pIsLiteralCalculation == NULL )
555 {
556 pIsLiteralCalculation = &dummyBool;
557 }
558 *pIsLiteralCalculation = true;
559
[75]560 if(expression[0]=='\0'){
[4]561 SetError(1,NULL,cp);
[75]562 return false;
[4]563 }
564
[75]565 if(expression[0]==1&& expression[1]==ESC_NEW ){
[4]566 //New演算子（オブジェクト生成）
[254]567 *pIsLiteralCalculation = false;
[75]568 return Operator_New_GetType(expression+2,baseType, resultType );
[4]569 }
570
[94]571 if( expression[0] == '[' ){
572 if( !baseType.IsPointer() ){
573 SetError(1,NULL,cp);
574 return false;
575 }
[4]576
[94]577 resultType = baseType;
578 return true;
579 }
580
581
[4]582 /////////////////////////////////
583 // 式要素を逆ポーランド式で取得
584 /////////////////////////////////
585
586 char *values[255];
587 long calc[255];
588 long stack[255];
589 int pnum;
[75]590 if(!GetNumOpeElements(expression,&pnum,values,calc,stack)){
[4]591 for(i=0;i<pnum;i++){
592 if(values[i]) HeapDefaultFree(values[i]);
593 }
[75]594 return false;
[4]595 }
596
597
598
599 ////////////////////////////////
600 // 演算部分のコード生成を開始
601 ////////////////////////////////
602
603 BOOL bError;
604 bError=0;
605
606 int sp;
[75]607 int type_stack[255];
[4]608 LONG_PTR index_stack[255];
[79]609 bool isNothing_stack[255];
[4]610 _int64 i64data;
611 int idCalc;
612 for(i=0,sp=0;i<pnum;i++){
613 idCalc=calc[i]%100;
614
615 if(idCalc){
[75]616 if(type_stack[sp-2]==DEF_OBJECT){
[79]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演算子を呼び出さない
[4]622 }
[94]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 }
[129]629 else if( idCalc == CALC_AS ){
630 // NumOpe_GetTypeではすべてのキャストを許可する
631 }
[79]632 else{
633 //オーバーロードされたオペレータを呼び出す
634 if(!GetReturnType_OperatorProc(idCalc,baseType,type_stack,index_stack,sp)){
635 goto error;
636 }
[4]637
[79]638 continue;
639 }
[4]640 }
641
[75]642 if(!CheckCalcType(idCalc,type_stack,sp)) goto error;
[4]643 }
644
645 switch(idCalc){
646 //数値
647 case 0:
648 index_stack[sp]=-1;
[79]649 isNothing_stack[sp] = false;
[4]650
[49]651 char *term;
652 term = values[i];
653
[97]654 if( calc[i+1]%100 == CALC_AS ){
655 // As演算子の右辺値
656 //型名
[198]657 if( compiler.StringToType( term, resultType ) ){
[128]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
[97]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
[49]689 if(term[0]=='\"'){
[4]690StrLiteral:
691
[97]692 if( baseType.IsObject() || baseType.IsNull() ){
693 //要求タイプがオブジェクト、または未定のとき
[75]694 type_stack[sp]=DEF_OBJECT;
[265]695 index_stack[sp]=(LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr();
[254]696 *pIsLiteralCalculation = false;
[4]697
[75]698 sp++;
699 break;
[4]700 }
701
[75]702 type_stack[sp]=typeOfPtrChar;
[254]703 *pIsLiteralCalculation = false;
[4]704 }
[49]705 else if((term[0]=='e'||term[0]=='E')&&
706 (term[1]=='x'||term[1]=='X')&&
707 term[2]=='\"'){
[4]708 //拡張版リテラル文字列（エスケープシーケンス可能）
709 goto StrLiteral;
710 }
[49]711 else if(IsVariableTopChar(term[0])||
712 term[0]=='*'||
713 (term[0]=='.'&&IsVariableTopChar(term[1]))){
[4]714 //////////////////
715 // 何らかの識別子
716
[97]717 bool isLiteral = true;
[331]718 if( GetTermType( term, baseType, resultType, isLiteral ) ){
[97]719 type_stack[sp] = resultType.GetBasicType();
720 index_stack[sp] = resultType.GetIndex();
[4]721
[97]722 if( !isLiteral ){
[254]723 *pIsLiteralCalculation = false;
[4]724 }
725
[97]726 sp++;
727 break;
[4]728 }
729
[38]730
[67]731 // Nothing
732 if( lstrcmp( term, "Nothing" ) == 0 ){
[79]733 isNothing_stack[sp] = true;
734
[75]735 type_stack[sp] = DEF_OBJECT;
736 if( baseType.IsObject() ){
737 index_stack[sp] = baseType.GetIndex();
[67]738 }
739 else{
[265]740 index_stack[sp] = (LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr();
[67]741 }
[254]742 *pIsLiteralCalculation = false;
[67]743 sp++;
744 break;
745 }
746
747
[4]748 //////////////
749 // 定数の場合
750 //////////////
751
[265]752 i3 = compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType(term);
[7]753 if(i3){
[265]754 if( compiler.GetObjectModule().meta.GetGlobalConsts().IsStringPtr( term ) ){
[103]755 //リテラル文字列
756 goto StrLiteral;
757 }
758
[75]759 type_stack[sp]=i3;
[4]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 //配列要素を排除
[97]784 char VarName[VN_SIZE],ArrayElements[VN_SIZE];
[49]785 GetArrayElement(term,VarName,ArrayElements);
[4]786
787 if(GetSubHash(VarName,0)){
[97]788 SetError();
[75]789 Type tempType;
790 GetReturnTypeOfPropertyMethod(term,NULL,tempType);
[4]791
792 //大きな型への暗黙の変換
[75]793 type_stack[sp]=tempType.GetBasicType();
[4]794
[75]795 index_stack[sp]=tempType.GetIndex();
[254]796 *pIsLiteralCalculation = false;
[4]797
798 sp++;
799 break;
800 }
801
802
803
804 //該当する識別子が見当たらないときはエラー扱いにする
805 bError=1;
[49]806 SetError(3,term,cp);
[75]807 type_stack[sp]=DEF_DOUBLE;
[4]808 }
809 else{
810 //リテラル値
[75]811 int base_type = 0;
812 if( !baseType.IsNull() ) base_type = baseType.GetBasicType();
813 type_stack[sp]=GetLiteralValue(term,&i64data,base_type);
[4]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--;
[75]826 type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
[4]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--;
[75]841 type_stack[sp-1]=DEF_LONG;
[4]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--;
[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_MOD:
858 //values[sp-2]%=values[sp-1]
859 //剰余演算
860 sp--;
[75]861 type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
[4]862 break;
863 case CALC_QUOTIENT:
864 //values[sp-2]/=values[sp-1];
865 //除算
866 sp--;
[75]867 type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
[4]868 break;
869 case CALC_INTQUOTIENT:
870 //values[sp-2]/=values[sp-1]
871 //整数除算
872 sp--;
[75]873 type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
[4]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 //キャスト
[75]886 type_stack[sp-2]=type_stack[sp-1]&(~FLAG_CAST);
[4]887 index_stack[sp-2]=index_stack[sp-1];
888
889 sp--;
890 break;
[41]891
892 case CALC_BYVAL:
893 //ポインタ型→参照型
[75]894 if( PTR_LEVEL( type_stack[sp-1] ) <= 0 ){
[41]895 //ポインタ型ではないとき
896 SetError( 3, NULL, cp );
897 goto error;
898 }
899
[75]900 type_stack[sp-1] = PTR_LEVEL_DOWN( type_stack[sp-1] );
[41]901 break;
[4]902 }
903 }
904
905 if(bError) goto error;
906
907 if(sp!=1){
908 SetError(1,NULL,cp);
909 goto error;
910 }
911
[254]912 if( *pIsLiteralCalculation ){
[4]913 //右辺値が数値の定数式の場合
[75]914 int base_type = 0;
915 if( !baseType.IsNull() ) base_type = baseType.GetBasicType();
916 Type tempType;
917 StaticCalculation(true, expression,base_type,&i64data,tempType);
[4]918
[75]919 type_stack[0]=tempType.GetBasicType();
920 index_stack[0]=tempType.GetIndex();
[4]921 }
922 else{
923 //右辺値が数値の定数式ではないとき
924 if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
925 }
926
[75]927 resultType.SetType( type_stack[0], index_stack[0] );
[4]928
[75]929 bool isSuccessful = true;
[4]930 goto finish;
931
932
933 //////////////////
934 // エラー処理
935 //////////////////
936
937error:
[75]938 isSuccessful = false;
[4]939 goto finish;
940
941
942finish:
943 for(i=0;i<pnum;i++){
944 if(values[i]) HeapDefaultFree(values[i]);
945 }
[75]946 return isSuccessful;
[4]947}
Note: See TracBrowser for help on using the repository browser.