Changeset 64 in dev for BasicCompiler_Common


Ignore:
Timestamp:
Mar 8, 2007, 2:49:34 AM (17 years ago)
Author:
dai_9181
Message:

すべてのオブジェクトを参照型に切り替えた。

Location:
BasicCompiler_Common
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler_Common/BasicFixed.h

    r55 r64  
    1313// 型
    1414////////////////
     15
     16#define DEF_NON         -1
    1517
    1618/* basic\command.sbp内の "_System_Type_***" 定数と同期が必要 */
    … …  
    4850#define DEF_ANY         0x00000015
    4951#define DEF_OBJECT      0x00000016
     52#define DEF_STRUCT      0x00000017
    5053#define DEF_ELLIPSE     0x00000018
    5154
    … …  
    6063#define PTR_LEVEL_DOWN(t)   t = MAKE_PTR_TYPE(NATURAL_TYPE(t),PTR_LEVEL(t)-1)
    6164
    62 #define DEF_PTR_BYTE    MAKE_PTR_TYPE(DEF_BYTE,1)
     65#define DEF_PTR_CHAR    MAKE_PTR_TYPE(DEF_CHAR,1)
    6366#define DEF_PTR_OBJECT  MAKE_PTR_TYPE(DEF_OBJECT,1)
     67#define DEF_PTR_STRUCT  MAKE_PTR_TYPE(DEF_STRUCT,1)
    6468
    6569
    … …  
    191195#define ESC_ENDINTERFACE    (char)0xAA
    192196#define ESC_OPERATOR        (char)0xAB
    193 

  • BasicCompiler_Common/Class.cpp

    r63 r64  
    101101
    102102int CMember::GetSize(){
    103     if( IsRef() ){
    104         // 参照型
    105         return PTR_SIZE;
    106     }
    107 
    108103    //メンバサイズを取得
    109104    return GetTypeSize(TypeInfo.type,TypeInfo.u.lpIndex);
    … …  
    126121            char temporary[VN_SIZE];
    127122            sprintf(temporary,"%s.%s",pobj_c->name,member->name);
    128             AddGlobalVariable(
     123            dim(
    129124                false,
    130125                temporary,
    131126                member->SubScripts,
    132                 &member->TypeInfo,
     127                member->TypeInfo,
    133128                GetTypeSize(member->TypeInfo.type,member->TypeInfo.u.lpIndex),
    134129                member->InitBuf,
    135130                member->ConstractParameter,
    136131                0);
    137 
    138             if(member->TypeInfo.type==DEF_OBJECT){
    139                 //エラー用
    140                 cp=member->source_code_address;
    141 
    142                 CallConstructor(temporary,
    143                     member->SubScripts,
    144                     member->TypeInfo,
    145                     member->ConstractParameter);
    146             }
    147132
    148133            //ネイティブコードバッファの再確保
    … …  
    220205    }
    221206}
     207
     208bool CClass::IsStructure() const
     209{
     210    return classType == CClass::Structure;
     211}
     212
    222213void CClass::Inherits( CClass *pInheritsClass ){
    223214    int i3;
    … …  
    437428        //アラインメントを算出
    438429        int member_size;
    439         if(pMember->TypeInfo.type==DEF_OBJECT){
     430        if(pMember->TypeInfo.type==DEF_STRUCT){
    440431            //メンバクラスのアラインメントを取得
    441432            member_size=pMember->TypeInfo.u.pobj_Class->GetAlignment();
    … …  
    500491        CMember *pMember = ppobj_Member[i];
    501492
    502         if(pMember->TypeInfo.type==DEF_OBJECT && pMember->IsRef() == false){
     493        if(pMember->TypeInfo.type==DEF_STRUCT){
    503494            //メンバクラスのアラインメントを取得
    504495            member_size=pMember->TypeInfo.u.pobj_Class->GetAlignment();
    … …  
    598589    //コンポジションの関係にあるメンバも検査する
    599590    for(int i=0;i < iMemberNum;i++){
    600         if(ppobj_Member[i]->TypeInfo.type==DEF_OBJECT && ppobj_Member[i]->IsRef() == false){
     591        if(ppobj_Member[i]->TypeInfo.type==DEF_OBJECT){
    601592            if(ppobj_Member[i]->TypeInfo.u.pobj_Class->IsAbstract())
    602593                return true;
    … …  
    805796
    806797                //クラスを追加
    807                 pobj_DBClass->AddClass(temporary,NowLine);
     798                CClass *pClass = pobj_DBClass->AddClass(temporary,NowLine);
     799                if( pClass ){
     800                    if( basbuf[NowLine+1] == ESC_CLASS ){
     801                        pClass->classType = CClass::Class;
     802                    }
     803                    else if( basbuf[NowLine+1] == ESC_INTERFACE ){
     804                        pClass->classType = CClass::Interface;
     805                    }
     806                    else{
     807                        pClass->classType = CClass::Structure;
     808                    }
     809                }
    808810        }
    809811    }
    … …  
    843845        if(psi->ParmNum==0) fConstructor=1;
    844846
     847        // TODO: 消す
    845848        //コピーコンストラクタ
    846849        if(psi->ParmNum==1){
    … …  
    953956    for(i=0;i<pobj_c->iMemberNum;i++){
    954957        CMember *pMember = pobj_c->ppobj_Member[i];
    955         if(pMember->TypeInfo.type==DEF_OBJECT && pMember->IsRef()==false ){
     958        if(pMember->TypeInfo.type==DEF_OBJECT){
    956959            //循環参照でないかをチェック
    957960            if(pobj_LoopRefCheck->check(pMember->TypeInfo.u.pobj_Class->name)){
    … …  
    976979    extern char *basbuf;
    977980    int i,i2,i3,sub_address,top_pos;
    978     DWORD dwClassType;
    979981    DWORD dwAccess;
    980982    char temporary[8192];
    … …  
    11321134            top_pos=i;
    11331135
    1134             dwClassType=basbuf[i+1];
     1136            const DWORD dwClassType=basbuf[i+1];
    11351137
    11361138            i+=2;
    … …  
    12631265                    i += 2;
    12641266                }
    1265 
     1267/*
    12661268                //Ref修飾子
    12671269                bool isRef = false;
    … …  
    12691271                    isRef = true;
    12701272                    i += 2;
    1271                 }
     1273                }*/
    12721274
    12731275                if(basbuf[i]==1&&(
    … …  
    13481350                        //静的メンバを追加
    13491351                        cp=i;   //エラー用
    1350                         pobj_c->AddStaticMember( dwAccess, isConst, isRef, temporary, i);
     1352                        pobj_c->AddStaticMember( dwAccess, isConst, false, temporary, i);
    13511353                    }
    13521354                    else{
    13531355                        //メンバを追加
    13541356                        cp=i;   //エラー用
    1355                         pobj_c->AddMember( dwAccess, isConst, isRef, temporary );
    1356 
    1357 
    1358                         if(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.type==DEF_OBJECT){
     1357                        pobj_c->AddMember( dwAccess, isConst, false, temporary );
     1358
     1359
     1360                        if(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.type==DEF_OBJECT||
     1361                            pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.type==DEF_STRUCT){
    13591362                            if(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.u.pobj_Class->ppobj_Member==0){
    13601363                                //参照先が読み取られていないとき
    … …  
    13761379                }
    13771380                else{
    1378                     // 文法エラーチェック
    1379                     if( isRef ){
    1380                         SetError(1,NULL,cp);
    1381                     }
    1382 
    13831381                    //メソッドを追加
    13841382                    cp=i;   //エラー用

  • BasicCompiler_Common/Class.h

    r63 r64  
    7979    std::vector<CMethod *> staticMethods;
    8080
     81    enum ClassType{
     82        Class,
     83        Structure,
     84        Interface,
     85    };
     86
     87    ClassType classType;
     88
    8189public:
    8290    //クラス名
    … …  
    100108    CClass(const char *name);
    101109    ~CClass();
     110
     111    bool IsStructure() const;
    102112
    103113    //継承させる
    … …  
    186196    //線形リスト用
    187197    CClass *pobj_NextClass;
     198
     199
     200    //メンバの参照方法
     201    enum RefType{
     202        Dot,            // obj.member
     203        Pointer,        // obj->member
     204        Non,            // no reference member
     205    };
    188206};
    189207

  • BasicCompiler_Common/Compile.cpp

    r56 r64  
    243243            break;
    244244        case COM_DELETE:
    245             OpcodeDelete(Command+2);
     245            OpcodeDelete(Command+2, false);
     246            break;
     247        case COM_SWEEPINGDELETE:
     248            OpcodeDelete(Command+2, true);
    246249            break;
    247250

  • BasicCompiler_Common/DebugMiddleFile.cpp

    r53 r64  
    1111
    1212void SetLpIndex_DebugFile(char *buffer,int *p,int type,LONG_PTR lpIndex){
    13     if(NATURAL_TYPE(type)==DEF_OBJECT){
     13    if(NATURAL_TYPE(type)==DEF_OBJECT || NATURAL_TYPE(type)==DEF_STRUCT){
    1414        lstrcpy(buffer+(*p),((CClass *)lpIndex)->name);
    1515        (*p)+=lstrlen(buffer+(*p))+1;
    … …  
    2323
    2424void GetLpIndex_DebugFile(char *buffer,int *p,int type,LONG_PTR *plpIndex){
    25     if(NATURAL_TYPE(type)==DEF_OBJECT){
     25    if(NATURAL_TYPE(type)==DEF_OBJECT || NATURAL_TYPE(type)==DEF_STRUCT){
    2626        char szClassName[VN_SIZE];
    2727        lstrcpy(szClassName,buffer+(*p));

  • BasicCompiler_Common/Intermediate_Step1.cpp

    r54 r64  
    22
    33void ChangeReturnCode(char *buffer){
     4
     5#ifdef _DEBUG
     6    //改行コードの整合性チェック
     7    for( int i=0; ; i++ ){
     8        if( buffer[i] == '\0' ){
     9            break;
     10        }
     11        if( buffer[i]!='\r' && buffer[i+1]=='\n'
     12            ||  buffer[i]=='\r' && buffer[i+1]!='\n' ){
     13                char temporary[255];
     14                strncpy( temporary, buffer + i-100, 130 );
     15                temporary[130] = 0;
     16                for(int i2=0; ;i2++){
     17                    if(temporary[i2]=='\r') temporary[i2]='A';
     18                    if(temporary[i2]=='\n') temporary[i2]='B';
     19                    if(temporary[i2]=='\0') break;
     20                }
     21                MessageBox( hOwnerEditor, temporary, "改行コードの整合性チェック", MB_OK | MB_ICONEXCLAMATION );
     22        }
     23    }
     24#endif
     25
    426    //改行コードのCRLFをLFに変換
    5     int i,i2;
    6     for(i=0,i2=0;;i++,i2++){
     27    for(int i=0,i2=0;;i++,i2++){
    728        if(buffer[i]=='\r'&&buffer[i+1]=='\n') i++;
    829        buffer[i2]=buffer[i];

  • BasicCompiler_Common/Intermediate_Step2.cpp

    r43 r64  
    582582        ComNum=COM_DELETE;
    583583    }
     584    else if( lstrcmpi( com, "_System_SweepingDelete" ) == 0 ){
     585        KillSpaces(Command+i,pam);
     586        ComNum=COM_SWEEPINGDELETE;
     587    }
    584588
    585589    //その他

  • BasicCompiler_Common/LexicalScoping.cpp

    r51 r64  
    182182
    183183
    184     int i3,i4;
     184    int i3;
    185185    int indexSystemGC=-1;
    186186    for( i3 = num - 1; i3 >= 0; i3-- ){     //確保したのと逆順序で解放するため、バックサーチにする
    … …  
    197197        if( pVar[i3].ScopeLevel != GetNowLevel() ) continue;
    198198
    199         if(pVar[i3].type==DEF_OBJECT&&pVar[i3].fRef&OBJECT_PARAMETER){
    200             //実態オブジェクトのパラメータを持つとき
    201 
    202             //デストラクタを呼び出す
    203             CMethod *method = pVar[i3].u.pobj_c->GetDestructorMethod();
    204             if( method ){
    205                 Opcode_CallProc("", method->psi,0,pVar[i3].name,DEF_OBJECT);
    206             }
     199        if(pVar[i3].type==DEF_STRUCT&&pVar[i3].fRef&OBJECT_PARAMETER){
     200            //構造体パラメータを持つとき
    207201
    208202            //メモリを解放する
    … …  
    241235            }
    242236        }
     237
     238        /*
     239        TODO: 消す
    243240        else if(pVar[i3].type==DEF_OBJECT&&pVar[i3].fRef==0){
    244241            //デストラクタの呼び出し
    … …  
    285282            }
    286283        }
     284        */
    287285    }
    288286

  • BasicCompiler_Common/NumOpe_GetType.cpp

    r55 r64  
    255255}
    256256
     257int Operator_New_GetType(const char *Parameter,LONG_PTR *plpIndex,const TYPEINFO &baseTypeInfo ){
     258    char TypeName[VN_SIZE],CreateParameter[VN_SIZE],objectSizeStr[VN_SIZE];
     259    int i,i2;
     260
     261    i=0;
     262
     263    if(Parameter[0]=='['){
     264        i=GetStringInBracket(objectSizeStr,Parameter);
     265
     266        SlideString(objectSizeStr+1,-1);
     267        objectSizeStr[i-2]=0;
     268    }
     269    else objectSizeStr[0]=0;
     270
     271    for(i2=0;;i++,i2++){
     272        if(Parameter[i]=='('){
     273            TypeName[i2]=0;
     274
     275            //コンストラクタに渡すパラメータを取得
     276            i2=GetStringInPare(CreateParameter,Parameter+i);
     277            RemoveStringPare(CreateParameter);
     278            i+=i2;
     279            if(Parameter[i]!='\0'){
     280                SetError(42,NULL,cp);
     281                return 0;
     282            }
     283            break;
     284        }
     285        TypeName[i2]=Parameter[i];
     286        if(Parameter[i]=='\0'){
     287            CreateParameter[0]=0;
     288            break;
     289        }
     290    }
     291
     292    int type;
     293    type=GetTypeFixed(TypeName,plpIndex);
     294
     295    if( baseTypeInfo.type == DEF_OBJECT ){
     296        return DEF_OBJECT;
     297    }
     298    return DEF_PTR_OBJECT;
     299}
     300
    257301int NumOpe_GetType(char *Command,TYPEINFO *pBaseType,LONG_PTR *plpIndex){
    258302    extern int cp;
    … …  
    265309    }
    266310
    267     if(Command[0]==1&&Command[1]==ESC_NEW){
     311    if(Command[0]==1&& Command[1]==ESC_NEW ){
    268312        //New演算子（オブジェクト生成）
    269         return DEF_PTR_OBJECT;
     313        return Operator_New_GetType(Command+2,plpIndex, *pBaseType );
    270314    }
    271315
    … …  
    333377                        if(pBaseType->type==DEF_OBJECT){
    334378                            if(IsStringSubsituation(pBaseType->u.pobj_Class)
    335                                 || IsStringObjectType(pBaseType)){
     379                                || IsStringObjectType(*pBaseType)){
    336380                                //要求タイプがオブジェクトであり、Stringの受け入れが可能な場合
    337381                                extern CClass *pobj_StringClass;
    … …  
    346390                    }
    347391
    348                     type[sp]=DEF_PTR_BYTE;
     392                    type[sp]=DEF_PTR_CHAR;
    349393                    bLiteralCalculation=0;
    350394                }

  • BasicCompiler_Common/Overload.cpp

    r50 r64  
    2828        char MethodName[VN_SIZE];
    2929        if( !SplitMemberName( name, NULL, MethodName ) ) lstrcpy( MethodName, name );
    30 
     30/*
    3131        //メソッドの場合は静的かどうかを調べる
    3232        bool isStatic = false;
    … …  
    3535            isStatic = pClass->IsExistStaticMethod( MethodName );
    3636        }
    37 
     37*/
    3838        //パラメータオブジェクトを生成
    3939        pobj_parameter=new CParameter(Parameter);

  • BasicCompiler_Common/Parameter.cpp

    r52 r64  
    5858    }
    5959
    60     ReturnTypeInfo.type=0;
    61     ReturnTypeInfo.u.lpIndex=0;
     60    ReturnTypeInfo.type=DEF_NON;
     61    ReturnTypeInfo.u.lpIndex=-1;
    6262}
    6363CParameter::CParameter(const PARAMETER_INFO *pParamInfo,const int ParmNum){
    … …  
    7070    this->ParmsNum=ParmNum;
    7171
    72     ReturnTypeInfo.type=0;
    73     ReturnTypeInfo.u.lpIndex=0;
     72    ReturnTypeInfo.type=DEF_NON;
     73    ReturnTypeInfo.u.lpIndex=-1;
    7474}
    7575CParameter::~CParameter(){
    … …  
    9999        if(Parms[i]){
    100100            TYPEINFO BaseType={ppi[i].type,ppi[i].u.index};
    101             type=NumOpe_GetType(Parms[i],&BaseType,&lpIndex);
     101            type=NumOpe_GetType(Parms[i],
     102                (overload_level==OVERLOAD_LEVEL0) ? NULL : &BaseType,
     103                &lpIndex);
    102104        }
    103105        else{
    … …  
    107109
    108110        if(type!=ppi[i].type){
    109             if(overload_level==OVERLOAD_LEVEL1){
     111            if(overload_level==OVERLOAD_LEVEL1 || overload_level == OVERLOAD_LEVEL0){
    110112                return 0;
    111113            }
    … …  
    121123        }
    122124        else{
    123             if(NATURAL_TYPE(type)==DEF_OBJECT){
     125            if(NATURAL_TYPE(type)==DEF_OBJECT || NATURAL_TYPE(type)==DEF_STRUCT){
    124126                if(lpIndex!=ppi[i].u.index) return 0;
    125127            }
    … …  
    130132        //戻り値も比較対象にする
    131133        if(ReturnTypeInfo.type==pReturnTypeInfo->type){
    132             if(NATURAL_TYPE(ReturnTypeInfo.type)==DEF_OBJECT){
    133                 if(ReturnTypeInfo.u.lpIndex != pReturnTypeInfo->u.lpIndex) return 0;
     134            if(NATURAL_TYPE(ReturnTypeInfo.type)==DEF_OBJECT
     135                || NATURAL_TYPE(ReturnTypeInfo.type)==DEF_STRUCT ){
     136                    if(ReturnTypeInfo.u.lpIndex != pReturnTypeInfo->u.lpIndex) return 0;
    134137            }
    135138        }
    … …  
    145148    psi=0;
    146149
    147     foreach( psi, subs ){
    148 
    149         TYPEINFO ReturnTypeInfo;
    150         ReturnTypeInfo.type=psi->ReturnType;
    151         ReturnTypeInfo.u.lpIndex=psi->u.ReturnIndex;
    152 
    153         //エラーチェック
    154         if(_overload_check(psi->pParmInfo,psi->ParmNum,&ReturnTypeInfo,OVERLOAD_LEVEL1)){
    155             if(sw){
    156                 SetError(52,name,cp);
    157                 return 0;
    158             }
    159             sw=1;
    160             break;
    161         }
    162     }
    163 
    164     if(!sw){
    165         foreach( psi, subs ){
     150    for( int level=OVERLOAD_MIN_LEVEL; level<=OVERLOAD_MAX_LEVEL; level++ ){
     151        foreach( SUBINFO *temp_psi, subs ){
    166152
    167153            TYPEINFO ReturnTypeInfo;
    168             ReturnTypeInfo.type=psi->ReturnType;
    169             ReturnTypeInfo.u.lpIndex=psi->u.ReturnIndex;
     154            ReturnTypeInfo.type=temp_psi->ReturnType;
     155            ReturnTypeInfo.u.lpIndex=temp_psi->u.ReturnIndex;
    170156
    171157            //エラーチェック
    172             if(_overload_check(psi->pParmInfo,psi->ParmNum,&ReturnTypeInfo,OVERLOAD_LEVEL2)){
     158            if(_overload_check(temp_psi->pParmInfo,temp_psi->ParmNum,&ReturnTypeInfo,level)){
    173159                if(sw){
    174160                    SetError(52,name,cp);
    … …  
    176162                }
    177163                sw=1;
     164
     165                psi = temp_psi;
    178166                break;
    179167            }
    180168        }
    181     }
    182 
    183     if(!sw){
    184         foreach( psi, subs ){
    185 
    186             TYPEINFO ReturnTypeInfo;
    187             ReturnTypeInfo.type=psi->ReturnType;
    188             ReturnTypeInfo.u.lpIndex=psi->u.ReturnIndex;
    189 
    190             //エラーチェック
    191             if(_overload_check(psi->pParmInfo,psi->ParmNum,&ReturnTypeInfo,OVERLOAD_LEVEL3)){
    192                 if(sw){
    193                     SetError(52,name,cp);
    194                     return 0;
    195                 }
    196                 sw=1;
    197                 break;
    198             }
    199         }
     169
     170        if( sw ) break;
    200171    }
    201172
    … …  
    212183    psi=0;
    213184
    214     foreach( psi, subs ){
    215 
    216         //エラーチェック
    217         if(_overload_check(psi->pParmInfo,psi->ParmNum,NULL,OVERLOAD_LEVEL1)){
    218             if(sw){
    219                 return OverloadSolutionWithReturnType(name,subs);
    220             }
    221             sw=1;
    222             break;
    223         }
    224     }
    225 
    226     if(!sw){
    227         foreach( psi, subs ){
     185    for( int level=OVERLOAD_MIN_LEVEL; level<=OVERLOAD_MAX_LEVEL; level++ ){
     186
     187        foreach( SUBINFO *temp_psi, subs ){
    228188
    229189            //エラーチェック
    230             if(_overload_check(psi->pParmInfo,psi->ParmNum,NULL,OVERLOAD_LEVEL2)){
     190            if(_overload_check(temp_psi->pParmInfo,temp_psi->ParmNum,NULL,level)){
    231191                if(sw){
    232192                    return OverloadSolutionWithReturnType(name,subs);
    233193                }
    234194                sw=1;
    235                 break;
    236             }
    237         }
    238     }
    239 
    240     if(!sw){
    241         foreach( psi, subs ){
    242 
    243             //エラーチェック
    244             if(_overload_check(psi->pParmInfo,psi->ParmNum,NULL,OVERLOAD_LEVEL3)){
    245                 if(sw){
    246                     return OverloadSolutionWithReturnType(name,subs);
    247                 }
    248                 sw=1;
    249                 break;
    250             }
    251         }
     195
     196                psi = temp_psi;
     197            }
     198        }
     199
     200        if( sw ) break;
    252201    }
    253202

  • BasicCompiler_Common/Subroutine.cpp

    r54 r64  
    460460    _int64 i64data;
    461461    type = StaticCalculation( true, temporary, 0, &i64data, &lpIndex );
    462     if( type != DEF_PTR_BYTE ){
     462    if( type != DEF_PTR_CHAR ){
    463463        SetError(1,NULL,NowLine);
    464464        return;
    … …  
    483483    if( temporary[0] ){
    484484        type = StaticCalculation( true, temporary, 0, &i64data, &lpIndex );
    485         if( type != DEF_PTR_BYTE ){
     485        if( type != DEF_PTR_CHAR ){
    486486            SetError(1,NULL,NowLine);
    487487            return;
    … …  
    604604        i+=2;
    605605        pdi->ReturnType=GetTypeFixed(buffer+i,&pdi->u.ReturnIndex);
    606         if(pdi->ReturnType==-1) SetError(3,buffer+i,NowLine);
     606        if(pdi->ReturnType==DEF_NON) SetError(3,buffer+i,NowLine);
    607607        if(pdi->ReturnType==DEF_OBJECT) SetError(40,NULL,NowLine);
    608608    }
    609609    else if(buffer[i]) SetError(1,NULL,NowLine);
    610     else pdi->ReturnType=-1;
     610    else pdi->ReturnType=DEF_NON;
    611611
    612612    pdi->pos=NowLine;
    … …  
    635635        }
    636636        else{
    637             if(NATURAL_TYPE(ppi1[i].type)==DEF_OBJECT){
     637            if(NATURAL_TYPE(ppi1[i].type)==DEF_OBJECT
     638                || NATURAL_TYPE(ppi1[i].type)==DEF_STRUCT ){
    638639                if(ppi1[i].u.index!=ppi2[i].u.index) return 1;
    639640            }
    … …  
    827828                }
    828829                psi->ReturnType=GetTypeFixed(temporary,&psi->u.ReturnIndex);
    829                 if(psi->ReturnType==-1) SetError(3,temporary,NowLine);
     830                if(psi->ReturnType==DEF_NON) SetError(3,temporary,NowLine);
    830831
    831832                sw_as=1;
    … …  
    842843    else{
    843844        //戻り値なしのSub定義
    844         psi->ReturnType=-1;
     845        psi->ReturnType=DEF_NON;
    845846        psi->u.ReturnIndex=-1;
    846847    }
    … …  
    11291130    }
    11301131
    1131     //リアルパラメータ領域を取得（_System_LocalThis、_System_ReturnValueを考慮して2つだけ多く確保する）
     1132    //リアルパラメータ領域を取得（_System_LocalThisを考慮して2つだけ多く確保する）
    11321133    psi->pRealParmInfo=(PARAMETER_INFO *)HeapAlloc(hHeap,0,(psi->ParmNum+2)*sizeof(PARAMETER_INFO));
    11331134    psi->RealParmNum=0;
    … …  
    11471148    }
    11481149
    1149     if(psi->ReturnType==DEF_OBJECT && psi->isReturnRef == false){
     1150    if(psi->ReturnType==DEF_STRUCT){
    11501151        i = psi->RealParmNum;
    11511152
    1152         //実体オブジェクトを戻り値として持つ場合
     1153        //構造体を戻り値として持つ場合
    11531154        //※第一パラメータ（Thisポインタありの場合は第二パラメータ）を戻り値用の参照宣言にする
    11541155
    … …  
    11561157            psi->pRealParmInfo[i].name="_System_ReturnValue";
    11571158        else psi->pRealParmInfo[i].name=psi->name;
    1158         psi->pRealParmInfo[i].type=DEF_OBJECT;
     1159        psi->pRealParmInfo[i].type=DEF_STRUCT;
    11591160        psi->pRealParmInfo[i].u.index=psi->u.ReturnIndex;
    11601161        psi->pRealParmInfo[i].bByVal=0;
    … …  
    15211522            }
    15221523            pi->ReturnType=GetTypeFixed(temporary,&pi->u.ReturnIndex);
    1523             if(pi->ReturnType==-1) SetError(3,temporary,cp);
    1524             if(pi->ReturnType==DEF_OBJECT) SetError(40,NULL,cp);
     1524            if(pi->ReturnType==DEF_NON) SetError(3,temporary,cp);
    15251525        }
    15261526        else pi->ReturnType=DEF_DOUBLE;
    15271527    }
    1528     else pi->ReturnType=-1;
     1528    else pi->ReturnType=DEF_NON;
    15291529
    15301530    return ProcPtrInfoNum-1;

  • BasicCompiler_Common/Variable.cpp

    r63 r64  
    157157    else if(IsPtrType(type))        return PTR_SIZE;
    158158
    159     else if(type==DEF_OBJECT){
     159    else if( type == DEF_STRUCT ){
    160160        CClass *pobj_c;
    161161        pobj_c=(CClass *)lpIndex;
    162         if(!pobj_c) return 0;
     162        if(!pobj_c){
     163            SetError(300,NULL,cp);
     164            return 0;
     165        }
     166
    163167        return pobj_c->GetSize();
     168    }
     169
     170    else if(type==DEF_OBJECT){
     171        return PTR_SIZE;
    164172    }
    165173    else{
    … …  
    232240    if(pobj_c){
    233241        *lpNum=(LONG_PTR)pobj_c;
    234         return DEF_OBJECT;
     242
     243        if( pobj_c->IsStructure() ){
     244            return DEF_STRUCT;
     245        }
     246        else{
     247            return DEF_OBJECT;
     248        }
    235249    }
    236250
    … …  
    282296
    283297    //オブジェクト
    284     else if(type==DEF_OBJECT){
     298    else if(type==DEF_OBJECT || type==DEF_STRUCT){
    285299        if(lpIndex==0) lstrcpy(name,"non");
    286300        else{
    … …  
    296310        else{
    297311            extern PROCPTRINFO *pProcPtrInfo;
    298             if(pProcPtrInfo[lpIndex].ReturnType==-1)
     312            if(pProcPtrInfo[lpIndex].ReturnType==DEF_NON)
    299313                lstrcpy(name,"*Sub");
    300314            else lstrcpy(name,"*Function");
    … …  
    316330}
    317331
    318 bool FormatUseProcReturnObject( const char *term, char *procName, char *parameter, int &RefType, char *member ){
     332bool FormatUseProcReturnObject( const char *term, char *procName, char *parameter, CClass::RefType &refType, char *member ){
    319333    int p1 = 0, p2 = 0;
    320334
    … …  
    323337        if( term[i] == '[' ){
    324338            i = JumpStringInBracket( term, i + 1 );
     339            if( term[i] == '\0' ) break;
    325340            continue;
    326341        }
    … …  
    328343            int temp_p = i;
    329344            i = JumpStringInPare( term, i + 1 ) + 1;
     345            if( term[i] == '\0' ) break;
    330346            if( term[i] == '.'
    331347                || term[i] == 1 && term[i] == ESC_PSMEM ){
    … …  
    348364    //参照タイプ
    349365    if( term[p2] == '.' ){
    350         RefType = DEF_OBJECT;
     366        refType = CClass::Dot;
    351367    }
    352368    else{
    353         RefType = DEF_PTR_OBJECT;
     369        refType = CClass::Pointer;
    354370        p2++;
    355371    }
    … …  
    361377}
    362378
    363 BOOL GetVarFormatString(char *buffer,char *array,char *array2,char *NestMember,int *pRefType){
     379BOOL GetVarFormatString(char *buffer,char *array,char *array2,char *NestMember,CClass::RefType &refType){
    364380    extern int cp;
    365381    int i,i2,i3;
    … …  
    369385    array2[0]=0;
    370386    NestMember[0]=0;
    371     *pRefType=0;
    372387    for(i=0;;i++){
    373388        if(buffer[i]=='\"'){
    … …  
    428443        if(buffer[i]=='.'){
    429444            lstrcpy(NestMember,buffer+i+1);
    430             *pRefType=DEF_OBJECT;
     445            refType = CClass::Dot;
    431446            buffer[i]=0;
    432447            break;
    … …  
    434449        if(buffer[i]==1&&buffer[i+1]==ESC_PSMEM){
    435450            lstrcpy(NestMember,buffer+i+2);
    436             *pRefType=DEF_PTR_OBJECT;
     451            refType = CClass::Pointer;
    437452            buffer[i]=0;
    438453            break;
    … …  
    614629    char lpPtrOffset[VN_SIZE];      //第2次配列
    615630    char NestMember[VN_SIZE];   //入れ子メンバ
    616     int object_type;            //"."参照のときは0、"->"参照のときは1
     631    CClass::RefType refType = CClass::Non;
    617632    lstrcpy(VarName,member);
    618     if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,&object_type)) return 0;
     633    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return 0;
    619634
    620635    for(i=0;i<pobj_c->iMemberNum;i++){
    … …  
    664679    }
    665680
    666     if(object_type){
     681    if( refType != CClass::Non ){
    667682        //入れ子構造の場合
    668683
    … …  
    704719
    705720
    706     int RefType;
    707     if( FormatUseProcReturnObject( variable, VarName, array, RefType, member ) ){
     721    CClass::RefType refType;
     722    if( FormatUseProcReturnObject( variable, VarName, array, refType, member ) ){
    708723        // 戻り値オブジェクトのメンバを直接参照しているとき
    709724        //例: func().member
    … …  
    723738
    724739    lstrcpy(VarName,variable);
    725     GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);
     740    GetVarFormatString(VarName,array,lpPtrOffset,member,refType);
    726741
    727742    int *pSubScripts;
    … …  
    825840        char tempMember[VN_SIZE];
    826841        char tempArray[VN_SIZE];
    827         GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,&i);
     842        {
     843            CClass::RefType refType;
     844            GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,refType);
     845        }
    828846
    829847        char temp2[VN_SIZE];
    … …  
    897915
    898916    if(member[0]){
    899         if(NATURAL_TYPE(type)==DEF_OBJECT)
    900             return GetMemberType((CClass *)lpIndex,member,plpIndex,0,bError);
     917        if( NATURAL_TYPE(type)==DEF_OBJECT
     918            || NATURAL_TYPE(type)==DEF_STRUCT){
     919                return GetMemberType((CClass *)lpIndex,member,plpIndex,0,bError);
     920        }
    901921    }
    902922
    … …  
    921941}
    922942
    923 BOOL GetVarOffsetReadOnly(const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss){
     943BOOL GetVarOffsetReadOnly(const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss ){
    924944    //読み取り専用で変数へアクセス
    925945    return GetVarOffset(
    … …  
    932952        pss);
    933953}
    934 BOOL GetVarOffsetReadWrite(const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss){
     954BOOL GetVarOffsetReadWrite(const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss ){
    935955    //読み書き両用で変数へアクセス
    936956    return GetVarOffset(
    … …  
    10951115    }
    10961116
     1117    /*
     1118    TODO: 消す
    10971119    if( pTypeInfo->type == DEF_OBJECT && InitBuf[0] != '\0' && InitBuf[0] != '[' && isRef == false ){
    10981120        if( pTypeInfo->u.pobj_Class->GetCopyConstructorMethod() ){
    … …  
    11011123            InitBuf[0] = 0;
    11021124        }
    1103     }
     1125    }*/
    11041126
    11051127    GetArrange(variable,VarName,SubScripts);
    … …  
    11911213    lstrcpy(pVar->ConstractParameter,ConstractParameter);
    11921214
    1193     if(InitBuf[0]||dwFlag==DIMFLAG_INITDEBUGVAR){
    1194         //初期バッファがあるとき
    1195         pVar->offset=AllInitGlobalVarSize;
    1196         AllInitGlobalVarSize+=VarSize;
    1197     }
    1198     else{
    1199         //初期バッファがないとき
    1200         pVar->offset=AllGlobalVarSize | 0x80000000;
    1201         AllGlobalVarSize+=VarSize;
    1202     }
    1203 
    12041215    //レキシカルスコープ
    12051216    pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
    … …  
    12101221    pVar->source_code_address=cp;
    12111222
    1212     //初期バッファにデータをセット
    1213     extern BYTE *initGlobalBuf;
    1214     initGlobalBuf=(BYTE *)HeapReAlloc(hHeap,
    1215         HEAP_ZERO_MEMORY,
    1216         initGlobalBuf,
    1217         AllInitGlobalVarSize);
     1223    //アラインメントを考慮
     1224    int alignment = 0;
     1225    if( pVar->type==DEF_STRUCT ){
     1226        alignment = pVar->u.pobj_c->iAlign;
     1227    }
     1228
     1229    if(InitBuf[0]||dwFlag==DIMFLAG_INITDEBUGVAR){
     1230        //初期バッファがあるとき
     1231
     1232        if( alignment ){
     1233            if( AllInitGlobalVarSize % alignment ){
     1234                AllInitGlobalVarSize += alignment - (AllInitGlobalVarSize % alignment);
     1235            }
     1236        }
     1237
     1238        pVar->offset=AllInitGlobalVarSize;
     1239        AllInitGlobalVarSize+=VarSize;
     1240    }
     1241    else{
     1242        //初期バッファがないとき
     1243
     1244        if( alignment ){
     1245            if( AllGlobalVarSize % alignment ){
     1246                AllGlobalVarSize += alignment - (AllGlobalVarSize % alignment);
     1247            }
     1248        }
     1249
     1250        pVar->offset=AllGlobalVarSize | 0x80000000;
     1251        AllGlobalVarSize+=VarSize;
     1252    }
     1253
    12181254    if(InitBuf[0]){
    1219         if( pVar->type == DEF_OBJECT && InitBuf[0] != '[' ){
    1220             //単発式が初期値のオブジェクトの場合
    1221             //初期値をコピーコンストラクタに渡す
    1222 
    1223             if( isRef ){
    1224                 SetRefVariable( name, InitBuf );
    1225             }
    1226         }
    1227         else{
    1228             int result = SetInitGlobalData(pVar->offset,
     1255        int result = 0;
     1256        if( pVar->type != DEF_OBJECT ){
     1257            //初期バッファにデータをセット
     1258            extern BYTE *initGlobalBuf;
     1259            initGlobalBuf=(BYTE *)HeapReAlloc(hHeap,
     1260                HEAP_ZERO_MEMORY,
     1261                initGlobalBuf,
     1262                AllInitGlobalVarSize);
     1263
     1264            result = SetInitGlobalData(pVar->offset,
    12291265                pVar->type,
    12301266                pVar->u.index,
    12311267                pVar->SubScripts,
    12321268                InitBuf);
    1233 
    1234             if(!result){
    1235                 //動的な式だった場合は代入演算を行う
    1236 
    1237                 //初期代入時のみ、書き込みアクセスを許可する
    1238                 bool bConstBack = pVar->bConst;
    1239                 pVar->bConst = false;
    1240 
    1241                 //代入
    1242                 char temporary[8192];
    1243                 sprintf(temporary,"%s=%s",name,InitBuf);
    1244                 OpcodeCalc(temporary);
    1245 
    1246                 //アクセス制限を元に戻す
    1247                 pVar->bConst = bConstBack;
    1248             }
     1269        }
     1270
     1271        if(!result){
     1272            //動的な式だった場合は代入演算を行う
     1273
     1274            //初期代入時のみ、書き込みアクセスを許可する
     1275            bool bConstBack = pVar->bConst;
     1276            pVar->bConst = false;
     1277
     1278            //代入
     1279            char temporary[8192];
     1280            sprintf(temporary,"%s=%s",name,InitBuf);
     1281            OpcodeCalc(temporary);
     1282
     1283            //アクセス制限を元に戻す
     1284            pVar->bConst = bConstBack;
    12491285        }
    12501286    }
    … …  
    12601296
    12611297/*
     1298    TODO: 消す
    12621299    if(pTypeInfo->type==DEF_OBJECT){
    12631300        //利用対象のクラスコンストラクタ、デストラクタに使用チェックをつける

  • BasicCompiler_Common/Variable.h

    r62 r64  
    1616void GetOriginalTypeName(char *buffer);
    1717BOOL GetTypeName(int type,LONG_PTR lpIndex,char *name);
    18 bool FormatUseProcReturnObject( const char *term, char *procName, char *parameter, int &RefType, char *member );
    19 BOOL GetVarFormatString(char *buffer,char *array,char *array2,char *NestMember,int *pRefType);
     18bool FormatUseProcReturnObject( const char *term, char *procName, char *parameter, CClass::RefType &refType, char *member );
     19BOOL GetVarFormatString(char *buffer,char *array,char *array2,char *NestMember, CClass::RefType &refType );
    2020void GetArrayElement(char *buffer,char *variable,char *array_element);
    2121BOOL CheckVarNameError(char *name,int NowLine);

  • BasicCompiler_Common/calculation.cpp

    r55 r64  
    524524                        StrPtr[pnum][i2]=0;
    525525
    526                         type[pnum]=DEF_PTR_BYTE;
     526                        type[pnum]=DEF_PTR_CHAR;
    527527                        before_index[pnum]=LITERAL_STRING;
    528528                    }
    … …  
    538538                        StrPtr[pnum][i2]=0;
    539539
    540                         type[pnum]=DEF_PTR_BYTE;
     540                        type[pnum]=DEF_PTR_CHAR;
    541541                        before_index[pnum]=LITERAL_STRING;
    542542                    }
    543                     else if(IsVariableTopChar(Parms[0])||Parms[0]=='*'){
     543                    else if(IsVariableTopChar(Parms[0])||Parms[0]=='*'||(Parms[0]=='.'&&IsVariableTopChar(Parms[1]))){
    544544                        if(bDebuggingWatchList){
    545545                            //////////////////////////
    … …  
    11871187    return -1;
    11881188}
    1189 BOOL IsStringObjectType(TYPEINFO *pTypeInfo){
    1190     if(pTypeInfo->type==DEF_OBJECT){
    1191         if(lstrcmp(pTypeInfo->u.pobj_Class->name,"String")==0){
     1189bool IsStringObjectType(const TYPEINFO &TypeInfo){
     1190    if(TypeInfo.type==DEF_OBJECT){
     1191        if(lstrcmp(TypeInfo.u.pobj_Class->name,"String")==0){
    11921192            return 1;
    11931193        }
    … …  
    12091209        if(psi->ParmNum==2){
    12101210            TYPEINFO TypeInfo={psi->pParmInfo[1].type,psi->pParmInfo[1].u.index};
    1211             if(IsStringObjectType(&TypeInfo)){
     1211            if(IsStringObjectType( TypeInfo )){
    12121212                bRet=1;
    12131213                goto finish;
    … …  
    12771277                        TypeInfo.type=pdi->ReturnType;
    12781278                        TypeInfo.u.lpIndex=pdi->u.ReturnIndex;
    1279                         if(IsStringObjectType(&TypeInfo)) return 1;
     1279                        if(IsStringObjectType( TypeInfo )) return 1;
    12801280                        return 0;
    12811281                    }
    … …  
    12871287                        TypeInfo.type=psi->ReturnType;
    12881288                        TypeInfo.u.lpIndex=psi->u.ReturnIndex;
    1289                         if(IsStringObjectType(&TypeInfo)) return 1;
     1289                        if(IsStringObjectType(TypeInfo)) return 1;
    12901290                        return 0;
    12911291                    }

  • BasicCompiler_Common/common.h

    r63 r64  
    546546BOOL GetConstCalcBuffer(char *name,char *Parameter,char *pCalcBuffer);
    547547DWORD GetConstValue(char *name,double *dbl,char *buffer,LONG_PTR *plpIndex);
    548 BOOL IsStringObjectType(TYPEINFO *pTypeInfo);
     548bool IsStringObjectType(const TYPEINFO &TypeInfo);
    549549BOOL IsStringSubsituation(CClass *pobj_c);
    550550int IsStrCalculation(char *Command);
    … …  
    615615//error.cpp
    616616void SetError(int ErrorNum,const char *KeyWord,int pos);
     617void SetError();
    617618void CompileMessage(char *buffer);
    618619bool CheckDifferentType(const int VarType,const LONG_PTR lpVarIndex,const int CalcType,const LONG_PTR lpCalcIndex,const char *pszFuncName,const int ParmNum);

  • BasicCompiler_Common/error.cpp

    r59 r64  
    183183    if(num==131) lstrcpy(msg,"Const定義されたメソッド内でクラスメンバへの書き込みアクセスはできません。");
    184184    if(num==132) lstrcpy(msg,"明示的なコンストラクタ呼び出しと初期値の指定を同時に行うことはできません。");
     185    if(num==133) lstrcpy(msg,"Thisに代入はできません。");
    185186
    186187    //Enum関連
    … …  
    359360    ErrorNum++;
    360361}
     362void SetError(){
     363    SetError(300,NULL,cp);
     364}
    361365void CompileMessage(char *buffer){
    362366    SetError(-2,buffer,-1);
    … …  
    397401
    398402bool CheckDifferentType(const int VarType,const LONG_PTR lpVarIndex,int CalcType,const LONG_PTR lpCalcIndex,const char *pszFuncName,const int ParmNum){
     403
     404    if(VarType==DEF_STRUCT||CalcType==DEF_STRUCT){
     405        //いずれかが構造体場合
     406        if( VarType != CalcType || lpVarIndex != lpCalcIndex ){
     407            DifferentTypeError(VarType,lpVarIndex,CalcType,lpCalcIndex,3,pszFuncName,ParmNum);
     408            return false;
     409        }
     410    }
    399411
    400412    if(VarType==DEF_OBJECT||CalcType==DEF_OBJECT){
Note: See TracChangeset for help on using the changeset viewer.