Changeset 49 in dev


Ignore:
Timestamp:
Feb 10, 2007, 6:13:37 AM (18 years ago)
Author:
dai_9181
Message:

戻り値オブジェクトのメンバを直接的に参照できるようにした。

Files:
12 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler32/Compile_Var.cpp

    r40 r49  
    362362    extern BOOL bCompilingGlobal;
    363363    int i,RefType;
     364    LONG_PTR lpIndex;
    364365    char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
    365366
    … …  
    370371    else lstrcpy(variable,NameBuffer);
    371372
     373
     374    if( FormatUseProcReturnObject( variable, VarName, array, RefType, member ) ){
     375        // 戻り値オブジェクトのメンバを直接参照しているとき
     376        //例: func().member
     377
     378        void *pInfo;
     379        int idProc=GetProc(VarName,&pInfo);
     380
     381        if(idProc){
     382            pRelativeVar->dwKind=VAR_DIRECTMEM;
     383
     384
     385            ////////////////
     386            // 呼び出し
     387            ////////////////
     388
     389            *pType=CallProc(idProc,pInfo,VarName,array,&lpIndex);
     390
     391            //戻り値をecxにコピー
     392            op_mov_RR( REG_ECX, REG_EAX );
     393
     394
     395            LONG_PTR lp2;
     396            if(!GetMemberOffset(
     397                isErrorEnabled,
     398                isWriteAccess,
     399                (CClass *)lpIndex,
     400                member,pType,pRelativeVar,&lp2,0)) return 0;
     401            if(plpIndex) *plpIndex=lp2;
     402
     403            return 1;
     404        }
     405    }
     406
     407
    372408    lstrcpy(VarName,variable);
    373409    GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);
    374410
    375     LONG_PTR lpIndex;
    376411    int *pSubScripts;
    377412    bool bConst;

  • BasicCompiler32/NumOpe.cpp

    r41 r49  
    284284
    285285                        if(idProc){
    286                             //閉じカッコ")"に続く文字がNULLでないときはエラーにする
    287                             if(term[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
     286                            //閉じカッコ")"に続く文字がNULLでないとき
     287                            if(term[i2+1+i4+1]!='\0'){
     288                                if( term[i2+1+i4+1] == '.'
     289                                    || term[i2+1+i4+1] == 1 && term[i2+1+i4+2] == ESC_PSMEM ){
     290                                        goto NonProc;
     291                                }
     292                                else{
     293                                    SetError(42,NULL,cp);
     294                                }
     295                            }
    288296
    289297                            ////////////////
    … …  
    351359                        }
    352360                    }
     361NonProc:
    353362
    354363

  • BasicCompiler32/Opcode.h

    r46 r49  
    3333#define VAR_DIRECTMEM   4   //Direct memory
    3434
     35
    3536extern int cp;
    3637extern int obp;
    3738extern char *OpBuffer;
     39
     40#define breakpoint OpBuffer[obp++]=(char)0xCC;
     41
    3842
    3943//ラベルアドレス

  • BasicCompiler64/Compile_Var.cpp

    r41 r49  
    388388    extern BOOL bCompilingGlobal;
    389389    int i,RefType;
     390    LONG_PTR lpIndex;
    390391    char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
    391392
    … …  
    396397    else lstrcpy(variable,NameBuffer);
    397398
     399    if( FormatUseProcReturnObject( variable, VarName, array, RefType, member ) ){
     400        // 戻り値オブジェクトのメンバを直接参照しているとき
     401        //例: func().member
     402
     403        void *pInfo;
     404        int idProc=GetProc(VarName,&pInfo);
     405
     406        if(idProc){
     407            pRelativeVar->dwKind=VAR_DIRECTMEM;
     408
     409            //////////////////////////////////////////////////////
     410            /////    レジスタ資源のバックアップ
     411            {   BACKUP_REGISTER_RESOURCE
     412            //////////////////////////////////////////////////////
     413
     414                ////////////////
     415                // 呼び出し
     416                ////////////////
     417
     418                *pType=CallProc(idProc,pInfo,VarName,array,&lpIndex);
     419
     420                //戻り値をr11にコピー
     421                op_mov_RR( REG_R11, REG_RAX );
     422
     423            /////////////////////////////////////////////
     424            //////   レジスタ資源を復元
     425                RESTORE_REGISTER_RESOURCE
     426            }////////////////////////////////////////////
     427
     428            LONG_PTR lp2;
     429            if(!GetMemberOffset(
     430                isErrorEnabled,
     431                isWriteAccess,
     432                (CClass *)lpIndex,
     433                member,pType,pRelativeVar,&lp2,0)) return 0;
     434            if(plpIndex) *plpIndex=lp2;
     435
     436            return 1;
     437        }
     438    }
     439
     440
     441
    398442    lstrcpy(VarName,variable);
    399443    GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);
    400444
    401     LONG_PTR lpIndex;
    402445    int *pSubScripts;
    403446    bool bConst = false;
    … …  
    565608    }
    566609
    567 
    568610    /////////////////////
    569611    // グローバル変数
    … …  
    635677    }
    636678
    637     if(array[0]||member[0]){
     679    if( array[0] || member[0] ){
    638680        //xor r11,r11（r11を0に初期化する）
    639681        //※r11は変数ベースアドレスからの相対オフセットを示す

  • BasicCompiler64/NumOpe.cpp

    r41 r49  
    314314
    315315                        if(idProc){
    316                             //閉じカッコ")"に続く文字がNULLでないときはエラーにする
    317                             if(term[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
     316                            //閉じカッコ")"に続く文字がNULLでないとき
     317                            if(term[i2+1+i4+1]!='\0'){
     318                                if( term[i2+1+i4+1] == '.'
     319                                    || term[i2+1+i4+1] == 1 && term[i2+1+i4+2] == ESC_PSMEM ){
     320                                        goto NonProc;
     321                                }
     322                                else{
     323                                    SetError(42,NULL,cp);
     324                                }
     325                            }
    318326
    319327
    … …  
    402410                        }
    403411                    }
     412NonProc:
    404413
    405414

  • BasicCompiler64/Opcode.h

    r46 r49  
    6262extern int obp;
    6363extern char *OpBuffer;
     64
     65#define breakpoint OpBuffer[obp++]=(char)0xCC;
     66
    6467
    6568//ラベルアドレス

  • BasicCompiler_Common/NumOpe_GetType.cpp

    r41 r49  
    327327                index_stack[sp]=-1;
    328328
    329                 if(values[i][0]=='\"'){
     329                char *term;
     330                term = values[i];
     331
     332                if(term[0]=='\"'){
    330333StrLiteral:
    331334
    … …  
    349352                    bLiteralCalculation=0;
    350353                }
    351                 else if((values[i][0]=='e'||values[i][0]=='E')&&
    352                     (values[i][1]=='x'||values[i][1]=='X')&&
    353                     values[i][2]=='\"'){
     354                else if((term[0]=='e'||term[0]=='E')&&
     355                    (term[1]=='x'||term[1]=='X')&&
     356                    term[2]=='\"'){
    354357                    //拡張版リテラル文字列（エスケープシーケンス可能）
    355358                    goto StrLiteral;
    356359                }
    357                 else if(IsVariableTopChar(values[i][0])||
    358                     values[i][0]=='*'||
    359                     (values[i][0]=='.'&&IsVariableTopChar(values[i][1]))){
     360                else if(IsVariableTopChar(term[0])||
     361                    term[0]=='*'||
     362                    (term[0]=='.'&&IsVariableTopChar(term[1]))){
    360363                    //////////////////
    361364                    // 何らかの識別子
    … …  
    365368                    //////////////////////////////////////
    366369
    367                     i2=GetCallProcName(values[i],temporary);
    368                     if(values[i][i2]=='('){
    369                         i4=GetStringInPare_RemovePare(temp2,values[i]+i2+1);
     370                    i2=GetCallProcName(term,temporary);
     371                    if(term[i2]=='('){
     372                        i4=GetStringInPare_RemovePare(temp2,term+i2+1);
    370373
    371374                        int idProc;
    … …  
    374377
    375378                        if(idProc){
    376                             //閉じカッコ")"に続く文字がNULLでないときはエラーにする
    377                             if(values[i][i2+1+i4+1]!='\0') SetError(42,NULL,cp);
     379                            //閉じカッコ")"に続く文字がNULLでないとき
     380                            if(term[i2+1+i4+1]!='\0'){
     381                                if( term[i2+1+i4+1] == '.'
     382                                    || term[i2+1+i4+1] == 1 && term[i2+1+i4+2] == ESC_PSMEM ){
     383                                        goto NonProc;
     384                                }
     385                                else{
     386                                    SetError(42,NULL,cp);
     387                                }
     388                            }
    378389
    379390
    … …  
    400411
    401412                            //閉じカッコ")"に続く文字がNULLでないときはエラーにする
    402                             if(values[i][i2+1+i4+1]!='\0') SetError(42,NULL,cp);
     413                            if(term[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
    403414
    404415                            //マクロ関数の場合
    … …  
    416427                        }
    417428                    }
    418 
     429NonProc:
    419430
    420431                    //インデクサ（getアクセサ）
    421432                    char VarName[VN_SIZE],ArrayElements[VN_SIZE];
    422                     GetArrayElement(values[i],VarName,ArrayElements);
     433                    GetArrayElement(term,VarName,ArrayElements);
    423434                    if(ArrayElements[0]){
    424435                        CClass *pobj_c;
    … …  
    440451
    441452
    442                     i2=GetVarType(values[i],&index_stack[sp],0);
     453                    i2=GetVarType(term,&index_stack[sp],0);
    443454                    if(i2!=-1){
    444455                        //////////
    … …  
    457468                    //////////////
    458469
    459                     i3 = CDBConst::obj.GetType(values[i]);
     470                    i3 = CDBConst::obj.GetType(term);
    460471                    if(i3){
    461472                        type[sp]=i3;
    … …  
    488499
    489500                    LONG_PTR lp;
    490                     i3=GetTypeFixed(values[i],&lp);
     501                    i3=GetTypeFixed(term,&lp);
    491502                    if(i3!=-1){
    492503                        type[sp]=i3|FLAG_CAST;
    … …  
    503514
    504515                    //配列要素を排除
    505                     GetArrayElement(values[i],VarName,ArrayElements);
     516                    GetArrayElement(term,VarName,ArrayElements);
    506517
    507518                    if(GetSubHash(VarName,0)){
    508519                        TYPEINFO RetTypeInfo;
    509                         GetReturnTypeOfPropertyMethod(values[i],NULL,&RetTypeInfo);
     520                        GetReturnTypeOfPropertyMethod(term,NULL,&RetTypeInfo);
    510521
    511522                        //大きな型への暗黙の変換
    … …  
    523534                    //該当する識別子が見当たらないときはエラー扱いにする
    524535                    bError=1;
    525                     SetError(3,values[i],cp);
     536                    SetError(3,term,cp);
    526537                    type[sp]=DEF_DOUBLE;
    527538                }
    … …  
    531542                    base_type=0;
    532543                    if(pBaseType) base_type=pBaseType->type;
    533                     type[sp]=GetLiteralValue(values[i],&i64data,base_type);
     544                    type[sp]=GetLiteralValue(term,&i64data,base_type);
    534545Literal:
    535546                    if((long)i64data==0&&index_stack[sp]==-1) index_stack[sp]=LITERAL_NULL;

  • BasicCompiler_Common/StrOperation.cpp

    r41 r49  
    317317    return i;
    318318}
    319 int JumpStringInPare(char *buffer,int pos){
     319int JumpStringInPare(const char *buffer,int pos){
    320320    int PareNum;
    321321    for(PareNum=1;;pos++){
    … …  
    335335    return 0;
    336336}
    337 int JumpStringInBracket(char *buffer,int pos){
     337int JumpStringInBracket(const char *buffer,int pos){
    338338    int PareNum;
    339339    for(PareNum=1;;pos++){

  • BasicCompiler_Common/Variable.cpp

    r46 r49  
    297297    TYPEINFO TypeInfo = { DEF_OBJECT, (LONG_PTR)pobj_StringClass };
    298298    return TypeInfo;
     299}
     300
     301bool FormatUseProcReturnObject( const char *term, char *procName, char *parameter, int &RefType, char *member ){
     302    int p1 = 0, p2 = 0;
     303
     304    for( int i=0; term[i]!='\0' ; i++ ){
     305
     306        if( term[i] == '[' ){
     307            i = JumpStringInBracket( term, i + 1 );
     308            continue;
     309        }
     310        if( term[i] == '(' ){
     311            int temp_p = i;
     312            i = JumpStringInPare( term, i + 1 ) + 1;
     313            if( term[i] == '.'
     314                || term[i] == 1 && term[i] == ESC_PSMEM ){
     315                    p1 = temp_p;
     316                    p2 = i;
     317            }
     318            continue;
     319        }
     320    }
     321    if( !p1 ) return false;
     322
     323    //メソッド名
     324    memcpy( procName, term, p1 );
     325    procName[p1] = 0;
     326
     327    //パラメータ
     328    memcpy( parameter, term + p1 + 1, p2 - p1 - 2 );
     329    parameter[ p2 - p1 - 2 ] = 0;
     330
     331    //参照タイプ
     332    if( term[p2] == '.' ){
     333        RefType = DEF_OBJECT;
     334    }
     335    else{
     336        RefType = DEF_PTR_OBJECT;
     337        p2++;
     338    }
     339
     340    //メンバ
     341    lstrcpy( member, term + p2 + 1 );
     342
     343    return true;
    299344}
    300345
    … …  
    632677    extern BOOL bCompilingGlobal;
    633678    int i;
     679    LONG_PTR lpIndex;
    634680    char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
    635681
    … …  
    640686    else lstrcpy(variable,NameBuffer);
    641687
     688
     689    int RefType;
     690    if( FormatUseProcReturnObject( variable, VarName, array, RefType, member ) ){
     691        // 戻り値オブジェクトのメンバを直接参照しているとき
     692        //例: func().member
     693
     694        void *pInfo;
     695        int idProc=GetProc(VarName,&pInfo);
     696
     697        if(idProc){
     698
     699            int type=GetReturnTypeOfProc(idProc,pInfo,VarName,array,&lpIndex);
     700
     701            return GetMemberType((CClass *)lpIndex,member,plpIndex,1,bError);
     702        }
     703    }
     704
     705
     706
    642707    lstrcpy(VarName,variable);
    643     GetVarFormatString(VarName,array,lpPtrOffset,member,&i);
     708    GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);
    644709
    645710    int *pSubScripts;
    646711    int type;
    647     LONG_PTR lpIndex;
    648712
    649713    extern int MaxGlobalVarNum;

  • BasicCompiler_Common/Variable.h

    r46 r49  
    1616void GetOriginalTypeName(char *buffer);
    1717BOOL GetTypeName(int type,LONG_PTR lpIndex,char *name);
     18bool FormatUseProcReturnObject( const char *term, char *procName, char *parameter, int &RefType, char *member );
    1819BOOL GetVarFormatString(char *buffer,char *array,char *array2,char *NestMember,int *pRefType);
    1920void GetArrayElement(char *buffer,char *variable,char *array_element);

  • BasicCompiler_Common/calculation.cpp

    r41 r49  
    519519                        i2=lstrlen(Parms);
    520520
    521 StrLiteral:
    522521                        nums[pnum]=i2;
    523522                        StrPtr[pnum]=(char *)HeapAlloc(hHeap,0,i2+1);

  • BasicCompiler_Common/common.h

    r46 r49  
    509509int GetStringInPare_RemovePare(char *buffer,char *ReadBuffer);
    510510int GetStringInBracket(char *buffer,const char *ReadBuffer);
    511 int JumpStringInPare(char *buffer,int pos);
    512 int JumpStringInBracket(char *buffer,int pos);
     511int JumpStringInPare(const char *buffer,int pos);
     512int JumpStringInBracket(const char *buffer,int pos);
    513513int GetCpFromLine(int LineNum);
    514514BOOL GetLineNum(int pos,int *pLine,char *FileName);
Note: See TracChangeset for help on using the changeset viewer.