Changeset 97 in dev for BasicCompiler32

Timestamp:

Apr 16, 2007, 3:52:40 AM (18 years ago)

Author:

dai_9181

Message:

関数の戻り値オブジェクトのメンバ・メソッドを一時オブジェクトを介さずに参照できるようにした。

Location:

BasicCompiler32

Files:

• Compile_Calc_PushVar.cpp (modified) (4 diffs)
• Compile_CallProc.cpp (modified) (2 diffs)
• Compile_Func.cpp (modified) (1 diff)
• Compile_Var.cpp (modified) (4 diffs)
• NumOpe.cpp (modified) (7 diffs)
• NumOpe_Relation.cpp (modified) (7 diffs)
• Opcode.h (modified) (7 diffs)
• op32_main.cpp (modified) (1 diff)

BasicCompiler32/Compile_Calc_PushVar.cpp

@@ -65 +65 @@
     }
 }
-void SetReg_WholeVariable(int type,RELATIVE_VAR *pRelativeVar,int reg){
+void SetReg_WholeVariable(int type,RELATIVE_VAR *pRelativeVar,int reg, bool is64Head){
     int varSize;
 
@@ -81 +81 @@
 
         //上位32ビットをedxにロード
-        pRelativeVar->offset+=sizeof(long);
-        SetReg_WholeVariable(DEF_LONG,pRelativeVar,REG_EDX);
-        pRelativeVar->offset-=sizeof(long);
+        SetReg_WholeVariable(DEF_LONG,pRelativeVar,REG_EDX, true);
 
         return;
     }
 
+    int offsetOf64Head = 0;
+    if( is64Head ){
+        offsetOf64Head = sizeof(long);
+    }
+
     if(pRelativeVar->dwKind==VAR_GLOBAL){
         if(pRelativeVar->bOffsetOffset){
             //mov reg, ptr[ecx+offset]
-            op_mov_RM(varSize,reg,REG_ECX,(int)pRelativeVar->offset,MOD_BASE_DISP32);
+            op_mov_RM(varSize,reg,REG_ECX,(int)pRelativeVar->offset + offsetOf64Head,MOD_BASE_DISP32);
         }
         else{
             //mov reg, ptr[offset]
-            op_mov_RM(varSize,reg,0,(int)pRelativeVar->offset,MOD_DISP32);
+            op_mov_RM(varSize,reg,0,(int)pRelativeVar->offset + offsetOf64Head,MOD_DISP32);
         }
         obp-=sizeof(long);
@@ -119 +122 @@
         if(pRelativeVar->bOffsetOffset){
             //mov reg, ptr[ebp+ecx+offset]
-            op_mov_RM_ex(varSize,reg,REG_EBP,REG_ECX,(int)pRelativeVar->offset,USE_OFFSET);
+            op_mov_RM_ex(varSize,reg,REG_EBP,REG_ECX,(int)pRelativeVar->offset + offsetOf64Head,USE_OFFSET);
         }
         else{
             //mov reg, ptr[ebp+offset]
-            op_mov_RM(varSize,reg,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
+            op_mov_RM(varSize,reg,REG_EBP,(int)pRelativeVar->offset + offsetOf64Head,MOD_BASE_DISP32);
         }
         obp-=sizeof(long);
@@ -146 +149 @@
     else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
 directmem:
-        //mov reg, ptr[ecx]
-        op_mov_RM(varSize,reg,REG_ECX,0,MOD_BASE);
+        if( is64Head ){
+            //mov reg, ptr[ecx]
+            op_mov_RM(varSize,reg,REG_ECX,offsetOf64Head,MOD_BASE_DISP8);
+        }
+        else{
+            //mov reg, ptr[ecx]
+            op_mov_RM(varSize,reg,REG_ECX,0,MOD_BASE);
+        }
     }
 }

BasicCompiler32/Compile_CallProc.cpp

@@ -116 +116 @@
     if( pUserProc->GetParentClassPtr() ){
         //クラスのメンバ関数を呼び出す場合はアクセスチェックを行う
-        if(ObjectName[0]){
+        if(ObjectName[0] && (dwFlags&PROCFLAG_NEW)==0){
             if(lstrcmpi(ObjectName,"Super")==0){
                 //クラスメンバ関数内から基底クラスの呼び出し
@@ -272 +272 @@
         //////////////////////////////////////////////////////
 
-        if(ObjectName[0]){
+        if(ObjectName[0] && (dwFlags&PROCFLAG_NEW)==0){
             if(lstrcmpi(ObjectName,"Super")==0) goto InClassMember;
             else{

BasicCompiler32/Compile_Func.cpp

@@ -205 +205 @@
     }
 
-    if( type.IsStringObject() ){
+    if( type.IsStringClass() ){
         //Stringオブジェクトの場合
         sprintf(temporary,"%s.Length",tempParm);

BasicCompiler32/Compile_Var.cpp

@@ -336 +336 @@
 
     return true;
-}
-void GetWithName(char *buffer){
-    extern WITHINFO WithInfo;
-    int i;
-
-    buffer[0]=0;
-    for(i=0;i<WithInfo.num;i++)
-        lstrcat(buffer,WithInfo.ppName[i]);
 }
 
@@ -836 +828 @@
     }
     else if( type.IsLong() || type.IsDWord() || type.IsPointer() ){
-        if(type.GetBasicType()==typeOfPtrChar&&calcType.GetIndex()==LITERAL_STRING){
+        if(type.GetBasicType()==typeOfPtrChar){
             //文字列定数のとき
 
@@ -1022 +1014 @@
     }
     else if( type.IsDWord() || type.IsLong() || type.IsPointer() ){
-        if(type.GetBasicType()==typeOfPtrChar&&calcType.GetIndex()==LITERAL_STRING){
+        if(type.GetBasicType()==typeOfPtrChar){
             //文字列定数のとき
 
@@ -1307 +1299 @@
     }
 }
+void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar){
+    if( reg != REG_EAX ){
+        SetError();
+        //TODO: 未完成
+    }
+    SetVarPtrToEax( pRelativeVar );
+}
 
 bool Compile_AddGlobalRootsForGc(){

BasicCompiler32/NumOpe.cpp

@@ -83 +83 @@
 }
 
-
+void ExtendRegToBigType( int reg, int bigBasicType, int baseBasicType ){
+    if( reg != REG_EAX ){
+        SetError();
+    }
+    switch( Type::GetBasicSize( bigBasicType ) ){
+        case sizeof(_int64):
+            ExtendTypeTo64(baseBasicType);
+            break;
+        case sizeof(long):
+            ExtendTypeTo32(baseBasicType,reg);
+            break;
+        case sizeof(short):
+            ExtendTypeTo16(baseBasicType,reg);
+            break;
+    }
+}
+
+
+
+bool VarToReg( RELATIVE_VAR &relativeVar, const Type &baseType, Type &resultType ){
+    const int useReg = REG_EAX;
+
+    //大きな型への暗黙の変換
+    int bigType = AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
+
+    if(resultType.GetBasicType()&FLAG_PTR){
+        //配列ポインタ
+        resultType.SetBasicType( GetPtrType(resultType.GetBasicType()^FLAG_PTR) );
+
+        SetVarPtrToReg(useReg, &relativeVar);
+    }
+    else if( resultType.IsStruct() ){
+        //構造体ポインタをeaxへ格納（構造体は値型）
+        SetVarPtrToReg(useReg, &relativeVar);
+    }
+    else if( resultType.IsReal() ){
+        // 実数
+        SetReg_RealVariable( resultType.GetBasicType(), &relativeVar );
+    }
+    else if( resultType.IsWhole() || resultType.IsObject()){
+        //整数型
+        SetReg_WholeVariable(resultType.GetBasicType(),&relativeVar,useReg);
+    }
+    else if( resultType.IsStruct() ){
+        //構造体ポインタをUseRegへ格納（構造体は値型）
+        SetVarPtrToReg(useReg,&relativeVar);
+    }
+    else{
+        return false;
+    }
+
+    if( resultType.GetBasicType() != bigType ){
+        // 大きな型へ変換された場合
+        // ※レジスタの値をキャストする
+        ExtendRegToBigType( useReg, bigType, resultType.GetBasicType() );
+
+        resultType.SetBasicType( bigType );
+    }
+
+    return true;
+}
+bool TermMemberOpe( const CClass &objClass, const Type &baseType, Type &resultType, const char *termFull, const char *termLeft, const char *member ){
+    const int useReg = REG_EAX;
+
+    if( GetMemberType( objClass, member, resultType, 0, false ) ){
+        // メンバが見つかったとき
+
+        //オブジェクトポインタをecxにコピー
+        op_mov_RR( REG_ECX, useReg );
+
+        RELATIVE_VAR relativeVar;
+        relativeVar.dwKind=VAR_DIRECTMEM;
+
+        if( !_member_offset(
+            true,   //エラー表示あり
+            false,  //読み込み専用
+            objClass,
+            member,&relativeVar,resultType,0)){
+                return false;
+        }
+
+        if( !VarToReg( relativeVar, baseType, resultType ) ){
+            SetError(11,termFull,cp);
+        }
+
+        return true;
+    }
+
+
+    ///////////////////////////////////////////////////////////////////
+    // 動的メソッドを検索
+    ///////////////////////////////////////////////////////////////////
+    vector<UserProc *> userProcs;
+
+    char methodName[VN_SIZE], lpPtrOffset[VN_SIZE], parameter[VN_SIZE], dummy[1];
+    CClass::RefType refType;
+    lstrcpy( methodName, member );
+    GetVarFormatString(methodName,parameter,lpPtrOffset,dummy,refType);
+
+    objClass.EnumMethod( methodName, userProcs );
+    UserProc *pUserProc;
+    if(userProcs.size()){
+        //オーバーロードを解決
+        pUserProc=OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);
+
+        if( pUserProc ){
+
+            resultType = pUserProc->ReturnType();
+
+            {
+                //オブジェクトポインタをスタックに入れておく
+                //push reg
+                op_push( useReg );
+
+                if( !Opcode_CallProc(parameter,pUserProc,PROCFLAG_NEW,termLeft,0 ) ){
+
+                    return false;
+                }
+
+                op_pop();
+
+                /////////////////////
+                // 戻り値の処理
+                /////////////////////
+
+                //大きな型への暗黙の変換
+                int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
+
+                if( resultType.GetBasicType() != bigType ){
+                    // 大きな型へ変換された場合
+                    // ※レジスタの値をキャストする
+                    ExtendRegToBigType( REG_EAX, bigType, resultType.GetBasicType() );
+
+                    resultType.SetBasicType( bigType );
+                }
+
+                //SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
+            }
+            
+            return true;
+        }
+    }
+
+    return false;
+}
+bool TermOpe( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, BOOL *pbUseHeap, bool *pIsClassName = NULL ){
+    char parameter[VN_SIZE];
+
+    // Withを解決
+    char termFull[VN_SIZE];
+    if(term[0]=='.'){
+        GetWithName(termFull);
+        lstrcat(termFull,term);
+    }
+    else lstrcpy(termFull,term);
+
+    char termLeft[VN_SIZE];
+    lstrcpy(termLeft,termFull);
+
+    // パース
+    char member[VN_SIZE];
+    CClass::RefType refType;
+    if( SplitMemberName( termFull, termLeft, member, refType ) ){
+        ///////////////////////////////////////////////////////////////////
+        // オブジェクトとメンバに分解できるとき
+        // termLeft.member
+        ///////////////////////////////////////////////////////////////////
+
+        isLiteral = false;
+
+        // オブジェクト側の型を取得
+        bool isClassName = false;
+        Type leftType;
+        if( !TermOpe( termLeft, baseType, leftType, isLiteral, pbUseHeap, &isClassName ) ){
+            return false;
+        }
+
+        if( isClassName ){
+            // 静的メンバ/メソッドの場合
+            goto globalArea;
+        }
+
+        if( !leftType.HasMember() ){
+            // メンバを持たない型の場合
+            return false;
+        }
+
+        return TermMemberOpe( leftType.GetClass(), baseType, resultType, termFull, termLeft, member );
+    }
+
+
+    //////////////////////////////////////////////
+    // クラス名かどうかをチェック（静的メンバ用）
+    //////////////////////////////////////////////
+
+    if( pIsClassName ){
+        if( pobj_DBClass->check( termFull ) ){
+            *pIsClassName = true;
+            return true;
+        }
+    }
+
+
+    /////////////////////////////////////////////////////////////////
+    // グローバル属性エリア
+    /////////////////////////////////////////////////////////////////
+globalArea:
+
+    const int useReg = REG_EAX;
+
+
+    if(lstrcmpi(termFull,"This")==0){
+        //Thisオブジェクト
+        resultType.SetType( DEF_OBJECT, pobj_CompilingClass );
+
+        SetThisPtrToReg( useReg );
+
+        isLiteral = false;
+
+        return true;
+    }
+
+
+    //////////////////////////////////////
+    // 関数（DLL、ユーザー定義、組み込み）
+    //////////////////////////////////////
+    char procName[VN_SIZE];
+    char temporary[8192];
+
+    int i2=GetCallProcName(termFull,procName);
+    if(termFull[i2]=='('){
+        int i4=GetStringInPare_RemovePare(parameter,termFull+i2+1);
+
+        void *pInfo;
+        int idProc=GetProc(procName,(void **)&pInfo);
+
+        if(idProc){
+            //閉じカッコ")"に続く文字がNULLでないとき
+            if(termFull[i2+1+i4+1]!='\0'){
+                SetError(42,NULL,cp);
+            }
+
+
+            {
+                ////////////////
+                // 呼び出し
+                ////////////////
+
+                CallProc(idProc,pInfo,procName,parameter,resultType);
+
+
+                /////////////////////
+                // 戻り値の処理
+                /////////////////////
+
+                //大きな型への暗黙の変換
+                int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
+
+                /*
+                ※後でNumOpe内でプッシュする
+                //スタックへプッシュ
+                PushReturnValue( resultType.GetBasicType() );
+                */
+
+                if( resultType.GetBasicType() != bigType ){
+                    // 大きな型へ変換された場合
+                    // ※レジスタの値をキャストする
+                    ExtendRegToBigType( useReg, bigType, resultType.GetBasicType() );
+
+                    resultType.SetBasicType( bigType );
+                }
+
+                //SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
+            }
+
+
+            if(resultType.IsStruct()){
+                //構造体が戻ったときはヒープ領域にインスタンスが格納されている
+                //※後にfreeする必要あり
+                // TODO: 解放はGCに任せる
+                *pbUseHeap = 1;
+            }
+
+            isLiteral = false;
+
+            return true;
+        }
+        else if(GetConstCalcBuffer(procName,parameter,temporary)){
+            /////////////////////////
+            // マクロ関数
+            /////////////////////////
+
+            //閉じカッコ")"に続く文字がNULLでないときはエラーにする
+            if(termFull[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
+
+            //マクロ関数の場合
+            NumOpe(useReg, temporary,Type(),resultType);
+
+            if(!IS_LITERAL(resultType.GetIndex())){
+                //リテラル値ではなかったとき
+                isLiteral = false;
+            }
+
+            return true;
+        }
+    }
+
+
+    ////////////////////////////////
+    // インデクサ（getアクセサ）
+    ////////////////////////////////
+
+    char VarName[VN_SIZE],ArrayElements[VN_SIZE];
+    GetArrayElement(termFull,VarName,ArrayElements);
+    if(ArrayElements[0]){
+        GetVarType(VarName,resultType,false);
+        if( resultType.IsObject() ){
+            CallIndexerGetterProc(/*UseReg,*/&resultType.GetClass(),VarName,ArrayElements,resultType);
+
+            isLiteral = false;
+
+            return true;
+        }
+    }
+
+
+    ////////////////////////////////
+    // 変数
+    ////////////////////////////////
+
+    RELATIVE_VAR relativeVar;
+    if(GetVarOffset(
+        false,  //エラー表示なし
+        false,  //読み込み専用
+        termFull,
+        &relativeVar,resultType)){
+        //////////
+        // 変数
+        //////////
+
+        if( !VarToReg( relativeVar, baseType, resultType ) ){
+            SetError(11,termFull,cp);
+        }
+
+        isLiteral = false;
+
+        return true;
+    }
+
+
+    /////////////////////////////////
+    // プロパティ用のメソッド
+    /////////////////////////////////
+
+    //配列要素を排除
+    GetArrayElement(termFull,VarName,ArrayElements);
+
+    if(GetSubHash(VarName,0)){
+
+        {
+            CallPropertyMethod(termFull,NULL,resultType);
+
+            //大きな型への暗黙の変換
+            int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
+
+            if( resultType.GetBasicType() != bigType ){
+                // 大きな型へ変換された場合
+                // ※レジスタの値をキャストする
+                ExtendRegToBigType( REG_EAX, bigType, resultType.GetBasicType() );
+
+                resultType.SetBasicType( bigType );
+            }
+
+            //SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
+        }
+
+
+        if(resultType.IsStruct()){
+            //構造体が戻ったときはヒープ領域にインスタンスが格納されている
+            //※後にfreeする必要あり
+            // TODO: 解放はGCに任せる
+            *pbUseHeap = 1;
+        }
+
+        isLiteral = false;
+
+        return true;
+    }
+
+
+    return false;
+}
+
+
+bool NumOpe( int reg,
+            const char *expression,
+            const Type &baseType,
+            Type &resultType,
+            BOOL *pbUseHeap ){
+
+    if( !NumOpe( expression, baseType, resultType, pbUseHeap ) ){
+        return false;
+    }
+
+    if( reg != REG_EAX ){
+        // TODO: 未実装
+        SetError();
+    }
+
+    if( resultType.IsReal() ){
+        //fld ptr[esp]
+        op_fld_ptr_esp( resultType.GetBasicType() );
+
+        //add esp,size
+        op_add_esp( resultType.GetBasicSize() );
+    }
+    else{
+        //pop eax
+        op_pop(REG_EAX);
+
+        if( resultType.Is64() ){
+            //pop edx
+            op_pop(REG_EDX);
+        }
+    }
+    return true;
+}
 bool NumOpe( const char *expression,
             const Type &baseType,
@@ -89 +515 @@
             BOOL *pbUseHeap ){
 
-    int i,i2,i3,i4;
-    char temporary[1024],temp2[1024],temp3[1024];
+    int i,i2,i3;
+    char temporary[1024],temp2[1024];
 
     if(expression[0]=='\0'){
@@ -260 +686 @@
                 term=values[i];
 
+                if( calc[i+1]%100 == CALC_AS ){
+                    // As演算子の右辺値
+                    //型名
+                    if( Type::StringToType( term, resultType ) ){
+                        resultType.SetBasicType( resultType.GetBasicType() | FLAG_CAST );
+                    }
+                    else{
+                        SetError(3, term, cp );
+                        goto error;
+                    }
+
+                    type_stack[sp] = resultType.GetBasicType();
+                    index_stack[sp] = resultType.GetIndex();
+                    sp++;
+
+                    break;
+                }
+
                 if(term[0]=='\"'){
                     //リテラル文字列
@@ -269 +713 @@
 StrLiteral:
 
-                    if( baseType.IsObject() ){
-                        if( baseType.IsStringObject() ){
-                            //要求タイプがStringのとき
-
-                            //String型オブジェクトを生成
-                            NewStringObject(term);
-
-                            extern CClass *pobj_StringClass;
-                            type_stack[sp]=DEF_OBJECT;
-                            index_stack[sp]=(LONG_PTR)pobj_StringClass;
-                            bLiteralCalculation=0;
-
-                            sp++;
-                            break;
-                        }
+                    if( baseType.IsObject() || baseType.IsNull() ){
+                        //要求タイプがオブジェクト、または未定のとき
+
+                        //String型オブジェクトを生成
+                        NewStringObject(term);
+
+                        extern CClass *pobj_StringClass;
+                        type_stack[sp]=DEF_OBJECT;
+                        index_stack[sp]=(LONG_PTR)pobj_StringClass;
+                        bLiteralCalculation=0;
+
+                        sp++;
+                        break;
                     }
 
@@ -317 +759 @@
                     // 何らかの識別子
 
-                    //////////////////////////////////////
-                    // 関数（DLL、ユーザー定義、組み込み）
-                    //////////////////////////////////////
-
-                    i2=GetCallProcName(term,temporary);
-                    if(term[i2]=='('){
-                        i4=GetStringInPare_RemovePare(temp2,term+i2+1);
-
-                        void *pInfo;
-                        int idProc=GetProc(temporary,(void **)&pInfo);
-
-                        Type resultType;
-                        if(idProc){
-                            //閉じカッコ")"に続く文字がNULLでないとき
-                            if(term[i2+1+i4+1]!='\0'){
-                                if( term[i2+1+i4+1] == '.'
-                                    || term[i2+1+i4+1] == 1 && term[i2+1+i4+2] == ESC_PSMEM ){
-                                        goto NonProc;
+                    bool isLiteral;
+                    if( TermOpe( term, baseType, resultType, isLiteral, &bUseHeap[sp] ) ){
+                        if(resultType.IsNull()){
+                            //戻り値が存在しないとき
+                            for(i2=0;;i2++){
+                                if(term[i2]=='('||term[i2]=='\0'){
+                                    term[i2]=0;
+                                    break;
+                                }
+                            }
+                            SetError(38,term,cp);
+
+                            goto error;
+                        }
+
+                        type_stack[sp] = resultType.GetBasicType();
+                        index_stack[sp] = resultType.GetIndex();
+
+                        if( !isLiteral ){
+                            bLiteralCalculation=0;
+                        }
+
+                        if( resultType.GetBasicType() & FLAG_CAST ){
+                            // 型名のみ
+                            SetError();
+                        }
+                        else{
+                            if( resultType.IsReal() ){
+                                //sub esp,size
+                                //fstp ptr[esp]
+                                op_fstp_push( resultType );
+                            }
+                            else{
+                                if( resultType.Is64() ){
+                                    //push edx
+                                    op_push( REG_EDX );
                                 }
                                 else{
-                                    SetError(42,NULL,cp);
+                                    ExtendTypeTo32( resultType.GetBasicType(), REG_EAX );
                                 }
+
+                                //push eax
+                                op_push( REG_EAX );
                             }
-
-                            ////////////////
-                            // 呼び出し
-                            ////////////////
-
-                            CallProc(idProc,pInfo,temporary,temp2,resultType);
-                            if(resultType.IsNull()){
-                                //戻り値が存在しないとき
-                                for(i2=2;;i2++){
-                                    if(term[i2]=='('||term[i2]=='\0'){
-                                        term[i2]=0;
-                                        break;
-                                    }
-                                }
-                                SetError(38,term,cp);
-
-                                goto error;
-                            }
-
-
-                            /////////////////////
-                            // 戻り値の処理
-                            /////////////////////
-
-                            //大きな型への暗黙の変換
-                            type_stack[sp]=AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
-                            index_stack[sp] = resultType.GetIndex();
-                            bLiteralCalculation=0;
-
-                            //スタックへプッシュ
-                            PushReturnValue( resultType.GetBasicType() );
-
-                            if( Is64Type(type_stack[sp])
-                                && resultType.IsWhole()
-                                && resultType.GetBasicSize() <= sizeof(long) ){
-                                    //必要に応じて64ビット拡張
-                                    ExtendStackTo64( resultType.GetBasicType() );
-                            }
-
-                            if( resultType.IsStruct() ){
-                                //構造体が戻ったときはヒープ領域にインスタンスが格納されている
-                                //※後にfreeする必要あり
-                                bUseHeap[sp]=1;
-                            }
-
-                            sp++;
-                            break;
                         }
-                        else if(GetConstCalcBuffer(temporary,temp2,temp3)){
-                            /////////////////////////
-                            // マクロ関数
-                            /////////////////////////
-
-                            //閉じカッコ")"に続く文字がNULLでないときはエラーにする
-                            if(term[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
-
-                            //マクロ関数の場合
-                            NumOpe(temp3,Type(),resultType);
-
-                            if(!IS_LITERAL(resultType.GetIndex())){
-                                //リテラル値ではなかったとき
-                                bLiteralCalculation=0;
-                            }
-
-                            type_stack[sp] = resultType.GetBasicType();
-                            index_stack[sp] = resultType.GetIndex();
-
-                            sp++;
-                            break;
-                        }
-                    }
-NonProc:
-
-
-                    //インデクサ（getアクセサ）
-                    char variable[VN_SIZE],array_element[VN_SIZE];
-                    GetArrayElement(term,variable,array_element);
-                    if(array_element[0]){
-                        Type resultType;
-                        GetVarType(variable,resultType,0);
-                        if( resultType.IsObject() ){
-                            CallIndexerGetterProc(&resultType.GetClass(),variable,array_element,resultType);
-                            type_stack[sp]=resultType.GetBasicType();
-                            index_stack[sp]=resultType.GetIndex();
-                            bLiteralCalculation=0;
-
-                            //push eax
-                            op_push(REG_EAX);
-
-                            sp++;
-                            break;
-                        }
+
+                        sp++;
+                        break;
                     }
 
@@ -451 +826 @@
                         //push 0
                         op_push_V( 0 );
-
-                        sp++;
-                        break;
-                    }
-
-                    RELATIVE_VAR RelativeVar;
-                    Type varType;
-                    if(GetVarOffset(
-                        false,  //エラー表示あり
-                        false,  //読み込み専用
-                        term,
-                        &RelativeVar,varType)){
-                        //////////
-                        // 変数
-                        //////////
-
-                        //大きな型への暗黙の変換
-                        type_stack[sp]=AutoBigCast(baseType.GetBasicType(),varType.GetBasicType());
-                        index_stack[sp] = varType.GetIndex();
-                        bLiteralCalculation=0;
-
-                        if(varType.GetBasicType()&FLAG_PTR){
-                            //配列ポインタ
-                            type_stack[sp]=GetPtrType(varType.GetBasicType()^FLAG_PTR);
-
-                            SetVarPtrToEax(&RelativeVar);
-
-                            //push eax
-                            op_push(REG_EAX);
-                        }
-                        else if( varType.IsStruct() ){
-                            //構造体ポインタをeaxへ格納（構造体は値型）
-                            SetVarPtrToEax(&RelativeVar);
-
-                            //push eax
-                            op_push(REG_EAX);
-                        }
-                        else if( varType.GetBasicSize() == sizeof(_int64) ){
-                            //64ビット型
-                            PushDoubleVariable(&RelativeVar);
-                        }
-                        else if( varType.GetBasicSize() == sizeof(long) ){
-                            //32ビット型
-                            PushLongVariable(&RelativeVar);
-                        }
-                        else if( varType.IsInteger() ){
-                            PushIntegerVariable(&RelativeVar);
-                        }
-                        else if( varType.IsWord() ){
-                            PushWordVariable(&RelativeVar);
-                        }
-                        else if( varType.IsSByte() ){
-                            PushCharVariable(&RelativeVar);
-                        }
-                        else if( varType.IsByte() || varType.IsBoolean() ){
-                            PushByteVariable(&RelativeVar);
-                        }
-                        else SetError(11,term,cp);
-
-                        if( Is64Type(type_stack[sp])
-                            && varType.IsWhole()
-                            && varType.GetBasicSize()<=sizeof(long)){
-                            //必要に応じて64ビット拡張
-                                ExtendStackTo64( varType.GetBasicType() );
-                        }
 
                         sp++;
@@ -556 +866 @@
 
 
-                    //////////////
-                    // 型名の場合
-                    //////////////
-                    Type tempType;
-                    if( Type::StringToType( term, tempType ) ){
-                        type_stack[sp] = tempType.GetBasicType() | FLAG_CAST;
-                        index_stack[sp] = tempType.GetIndex();
-                        sp++;
-                        break;
-                    }
-
-
-                    /////////////////////////////////
-                    // プロパティ用のメソッド
-                    /////////////////////////////////
-
-                    //配列要素を排除
-                    char VarName[VN_SIZE],ArrayElements[VN_SIZE];
-                    GetArrayElement(term,VarName,ArrayElements);
-
-                    if(GetSubHash(VarName,0)){
-                        Type resultType;
-                        CallPropertyMethod(term,NULL,resultType);
-
-                        //大きな型への暗黙の変換
-                        type_stack[sp]=AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
-                        index_stack[sp]=resultType.GetIndex();
-                        bLiteralCalculation=0;
-
-                        //スタックへプッシュ
-                        PushReturnValue( resultType.GetBasicType() );
-
-                        if(type_stack[sp]==DEF_STRUCT){
-                            //構造体が戻ったときはヒープ領域にインスタンスが格納されている
-                            //※後にfreeする必要あり
-                            bUseHeap[sp]=1;
-                        }
-
-                        sp++;
-                        break;
-                    }
-
-
-
                     //該当する識別子が見当たらないときはエラー扱いにする
                     bError=1;

BasicCompiler32/NumOpe_Relation.cpp

@@ -1 +1 @@
 #include "../BasicCompiler_Common/common.h"
 #include "Opcode.h"
+
+void AutoExtendToBigType( int *type_stack,int sp, int reg1, int reg2 ){
+    /*
+    int bigSize = GetTypeSize( type_stack[sp-1], -1 );
+    if( bigSize != GetTypeSize( type_stack[sp-2], -1 ) ){
+        int extReg = reg2;
+        int oldType = type_stack[sp-2];
+        if( bigSize < GetTypeSize( type_stack[sp-2], -1 ) ){
+            bigSize = GetTypeSize( type_stack[sp-2], -1 );
+            extReg = reg1;
+            oldType = type_stack[sp-1];
+        }
+        if( bigSize == 2 ){
+            ExtendTypeTo16( oldType, extReg );
+        }
+        else if( bigSize == 4 ){
+            ExtendTypeTo32( oldType, extReg );
+        }
+        else{
+            SetError();
+        }
+    }*/
+}
+
 
 BOOL Calc_Relation_PE(int *type_stack,LONG_PTR *index_stack,int *pStackPointer){
@@ -195 +219 @@
         //pop eax
         op_pop(REG_EAX);
+
+        // どちらかのサイズが足りない場合は自動拡張する
+        AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
 
         //sub esp,4
@@ -434 +461 @@
         op_pop(REG_EAX);
 
+        // どちらかのサイズが足りない場合は自動拡張する
+        AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
+
         //sub esp,4
         op_sub_esp(4);
@@ -675 +705 @@
         op_pop(REG_EAX);
 
+        // どちらかのサイズが足りない場合は自動拡張する
+        AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
+
         //sub esp,4
         op_sub_esp(4);
@@ -911 +944 @@
         //pop eax
         op_pop(REG_EAX);
+
+        // どちらかのサイズが足りない場合は自動拡張する
+        AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
 
         //sub esp,4
@@ -1115 +1151 @@
         op_pop(REG_EBX);
 
+        // どちらかのサイズが足りない場合は自動拡張する
+        AutoExtendToBigType( type, sp, REG_EAX, REG_EBX );
+
         //sub esp,4
         op_sub_esp(4);
@@ -1306 +1345 @@
         op_pop(REG_EBX);
 
+        // どちらかのサイズが足りない場合は自動拡張する
+        AutoExtendToBigType( type, sp, REG_EAX, REG_EBX );
+
         //sub esp,4
         op_sub_esp(4);

BasicCompiler32/Opcode.h

@@ -102 +102 @@
 //NumOpe.cpp
 void PushReturnValue(int type);
+bool NumOpe( int reg,
+            const char *expression,
+            const Type &baseType,
+            Type &resultType,
+            BOOL *pbUseHeap = NULL );
 bool NumOpe( const char *Command,
            const Type &baseType,
@@ -151 +156 @@
 void Set8Variable(int type,DWORD VarKind,DWORD offset,BOOL bOffsetOffset);
 void SetBooleanVariable(int type,RELATIVE_VAR *pRelative);
+void ExtendTypeTo64(int type);
+void ExtendTypeTo32(int type,int reg);
+void ExtendTypeTo16(int type,int reg);
 
 //increment.cpp
@@ -168 +176 @@
 //Compile_Calc_PushVar.cpp
 void SetReg_RealVariable(int type,RELATIVE_VAR *pRelativeVar);
-void SetReg_WholeVariable(int type,RELATIVE_VAR *pRelativeVar,int reg);
+void SetReg_WholeVariable(int type,RELATIVE_VAR *pRelativeVar,int reg, bool is64Head = false);
 void PushDoubleVariable(RELATIVE_VAR *pRelativeVar);
 void PushLongVariable(RELATIVE_VAR *pRelativeVar);
@@ -182 +190 @@
 //Compile_Var.cpp
 void SetRelativeOffset( RELATIVE_VAR &relativeVar );
-void GetWithName(char *buffer);
+bool _member_offset(bool isErrorEnabled, bool isWriteAccess, const CClass &objClass, const char *member, RELATIVE_VAR *pRelativeVar, Type &resultType, BOOL bPrivateAccess);
 void SetThisPtrToReg(int reg);
 bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType,int *pss = 0);
@@ -192 +200 @@
 void dim( char *VarName,int *SubScripts,Type &type,char *InitBuf,char *ConstractParameter,DWORD dwFlags);
 void SetVarPtrToEax(RELATIVE_VAR *pRelativeVar);
+void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar);
 bool Compile_AddGlobalRootsForGc();
 
@@ -314 +323 @@
 void op_push(int reg);
 void op_push_V(long data);
-void op_pop(int reg);
+void op_pop(int reg = REG_NON);
 void op_add_esp(int num);
 void op_sub_esp(int num);
@@ -328 +337 @@
 void op_fstp_base_offset    (int type,int base_reg,int offset);
 void op_fstp_base_offset_ex (int type,int base_reg1,int base_reg2,int offset,BOOL bUseOffset);
+void op_fstp_push           ( Type &type );
 void op_fistp_ptr_esp       ( int typeSize );
 void op_zero_reg(int reg);

BasicCompiler32/op32_main.cpp

@@ -864 +864 @@
         SetError();
     }
+}
+void op_fstp_push( Type &type ){
+    //sub esp,size
+    op_sub_esp( type.GetBasicSize() );
+
+    op_fstp_basereg( type.GetBasicType(), REG_ESP );
 }