Changeset 319 in dev for trunk/abdev


Ignore:
Timestamp:
Sep 9, 2007, 12:37:48 PM (17 years ago)
Author:
dai_9181
Message:

GCのバグをいくつか修正

Location:
trunk/abdev
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/abdev/BasicCompiler32/Compile_Object.cpp

    r303 r319  
    205205
    206206
     207    //仮想関数テーブルを初期化
     208    if( classObj.IsExistVirtualFunctions()
     209        && !classObj.IsAbstract() )
     210    {
     211        // mov ecx,vtblAddress
     212        compiler.codeGenerator.op_mov_RV_vtbl( REG_ECX, &classObj );
     213
     214        //mov dword ptr[eax],ecx
     215        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
     216
     217        // 仮想関数になるメソッドに使用チェックをつける
     218        BOOST_FOREACH( const CMethod *pMethod, classObj.GetMethods() )
     219        {
     220            if( pMethod->IsVirtual() )
     221            {
     222                pMethod->GetUserProc().Using();
     223            }
     224        }
     225    }
     226
     227
    207228    // ※ここでプッシュされた値はNew演算子の戻り値となる
    208229    //push eax

  • trunk/abdev/BasicCompiler32/Compile_ProcOp.cpp

    r316 r319  
    536536                }
    537537            }
    538 
    539             //仮想関数テーブルを初期化
    540             if( compiler.pCompilingClass->IsExistVirtualFunctions()
    541                 && !compiler.pCompilingClass->IsAbstract() )
    542             {
    543                 // mov eax,vtblAddress
    544                 compiler.codeGenerator.op_mov_RV_vtbl( REG_EAX, compiler.pCompilingClass );
    545 
    546                 //Thisポインタをecxにコピー
    547                 SetThisPtrToReg(REG_ECX);
    548 
    549                 //mov dword ptr[ecx],eax
    550                 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ECX, 0, MOD_BASE );
    551 
    552 
    553                 // 仮想関数になるメソッドに使用チェックをつける
    554                 BOOST_FOREACH( const CMethod *pMethod, compiler.pCompilingClass->GetMethods() )
    555                 {
    556                     if( pMethod->IsVirtual() )
    557                     {
    558                         pMethod->GetUserProc().Using();
    559                     }
    560                 }
    561             }
    562538        }
    563539        else if( pUserProc->IsDestructor() ){

  • trunk/abdev/BasicCompiler32/NumOpe.cpp

    r301 r319  
    7373
    7474    char *parameter = (char *)malloc( lstrlen( str ) + 32 );
    75     sprintf( parameter, "\"%s\"%c%c*Char", str, 1, ESC_AS );
    76     SetStringQuotes( parameter );
     75    sprintf( parameter, "%s%c%c*Char", str, 1, ESC_AS );
    7776
    7877    Operator_New( *compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr(), "", parameter, Type( DEF_OBJECT, *compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr() ) );
    … …  
    763762                }
    764763
    765                 if(term[0]=='\"'){
    766                     //リテラル文字列
    767                     if(!RemoveStringQuotes(term)){
    768                         SetError(43,NULL,cp);
    769                         goto error;
    770                     }
    771                     i3=lstrlen(term);
    772 StrLiteral:
    773 
    774                     if( baseType.IsObject() || baseType.IsNull() ){
     764                if( (term[0]=='e'||term[0]=='E')
     765                    && (term[1]=='x'||term[1]=='X')
     766                    && term[2]=='\"'
     767                    || term[0] == '\"' )
     768                {
     769                    if( baseType.IsObject() || baseType.IsNull() )
     770                    {
    775771                        //要求タイプがオブジェクト、または未定のとき
    776772
    … …  
    786782                    }
    787783
    788 
     784                    bool isEx = true;
     785                    if( term[0] == '\"' )
     786                    {
     787                        isEx = false;
     788                    }
     789
     790                    if( isEx )
     791                    {
     792                        // 拡張版リテラル文字列（エスケープシーケンス可能）
     793                        if(!RemoveStringQuotes(term+2)){
     794                            SetError(43,NULL,cp);
     795                            goto error;
     796                        }
     797                        i3=FormatString_EscapeSequence(term+2);
     798                        term+=2;
     799                    }
     800                    else
     801                    {
     802                        // 通常文字列
     803                        if(!RemoveStringQuotes(term)){
     804                            SetError(43,NULL,cp);
     805                            goto error;
     806                        }
     807                        i3=lstrlen(term);
     808                    }
     809StrLiteral:
    789810                    type_stack[sp]=typeOfPtrChar;
    790811                    bLiteralCalculation=0;
    … …  
    794815                    //push DataSize
    795816                    compiler.codeGenerator.op_push_V( i2, Schedule::DataTable );
    796                 }
    797                 else if((term[0]=='e'||term[0]=='E')&&
    798                     (term[1]=='x'||term[1]=='X')&&
    799                     term[2]=='\"'){
    800                     //拡張版リテラル文字列（エスケープシーケンス可能）
    801                     if(!RemoveStringQuotes(term+2)){
    802                         SetError(43,NULL,cp);
    803                         goto error;
    804                     }
    805                     i3=FormatString_EscapeSequence(term+2);
    806                     term+=2;
    807 
    808                     goto StrLiteral;
    809817                }
    810818                else if(IsVariableTopChar(term[0])||
    … …  
    896904                            //リテラル文字列
    897905
     906                            if( baseType.IsObject() || baseType.IsNull() )
     907                            {
     908                                //要求タイプがオブジェクト、または未定のとき
     909
     910                                //String型オブジェクトを生成
     911                                NewStringObject(term);
     912
     913                                type_stack[sp]=DEF_OBJECT;
     914                                index_stack[sp]=(LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr();
     915                                bLiteralCalculation=0;
     916
     917                                sp++;
     918                                break;
     919                            }
     920
    898921                            double dbl = compiler.GetObjectModule().meta.GetGlobalConsts().GetDoubleData(term);
    899922                            memcpy(&i64data,&dbl,sizeof(double));

  • trunk/abdev/BasicCompiler64/Compile_Object.cpp

    r308 r319  
    200200
    201201
     202    //仮想関数テーブルを初期化
     203    if( classObj.IsExistVirtualFunctions()
     204        && !classObj.IsAbstract() )
     205    {
     206        // mov rcx,vtblAddress
     207        compiler.codeGenerator.op_mov_RV_vtbl( REG_RCX, &classObj );
     208
     209        //mov qword ptr[rax],rcx
     210        compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RCX,REG_RAX,0,MOD_BASE);
     211
     212
     213        // 仮想関数になるメソッドに使用チェックをつける
     214        BOOST_FOREACH( const CMethod *pMethod, classObj.GetMethods() )
     215        {
     216            if( pMethod->IsVirtual() )
     217            {
     218                pMethod->GetUserProc().Using();
     219            }
     220        }
     221    }
     222
     223
    202224    /////////////////////////////////////////////////////////////////////
    203225

  • trunk/abdev/BasicCompiler64/Compile_ProcOp.cpp

    r318 r319  
    507507                }
    508508            }
    509 
    510             //仮想関数テーブルを初期化
    511             if( compiler.pCompilingClass->IsExistVirtualFunctions()
    512                 && !compiler.pCompilingClass->IsAbstract() )
    513             {
    514                 // mov rax,vtblAddress
    515                 compiler.codeGenerator.op_mov_RV_vtbl( REG_RAX, compiler.pCompilingClass );
    516 
    517                 //Thisポインタをrcxにコピー
    518                 SetThisPtrToReg(REG_RCX);
    519 
    520                 //mov qword ptr[rcx],rax
    521                 compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,REG_RCX,0,MOD_BASE);
    522 
    523 
    524                 // 仮想関数になるメソッドに使用チェックをつける
    525                 BOOST_FOREACH( const CMethod *pMethod, compiler.pCompilingClass->GetMethods() )
    526                 {
    527                     if( pMethod->IsVirtual() )
    528                     {
    529                         pMethod->GetUserProc().Using();
    530                     }
    531                 }
    532             }
    533509        }
    534510        else if( pUserProc->IsDestructor() ){

  • trunk/abdev/BasicCompiler64/NumOpe.cpp

    r318 r319  
    2222
    2323        char *parameter = (char *)malloc( lstrlen( str ) + 32 );
    24         sprintf( parameter, "\"%s\"%c%c*Char", str, 1, ESC_AS );
    25         SetStringQuotes( parameter );
     24        sprintf( parameter, "%s%c%c*Char", str, 1, ESC_AS );
    2625
    2726        Operator_New( *compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr(), "", parameter, Type( DEF_OBJECT, *compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr() ) );
    … …  
    429428    GetArrayElement(termFull,VarName,ArrayElements);
    430429    if(ArrayElements[0]){
    431         GetVarType(VarName,resultType,false);
    432         if( resultType.IsObject() ){
    433             CallIndexerGetterProc(UseReg,resultType,VarName,ArrayElements,resultType);
     430        Type classType;
     431        GetVarType(VarName,classType,false);
     432        if( classType.IsObject() )
     433        {
     434            CallIndexerGetterProc(UseReg,classType,VarName,ArrayElements,resultType);
    434435
    435436            isLiteral = false;
    … …  
    788789                }
    789790
    790                 if(term[0]=='\"'){
    791                     //リテラル文字列
    792                     if(!RemoveStringQuotes(term)){
    793                         SetError(43,NULL,cp);
    794                         goto error;
    795                     }
    796                     i3=lstrlen(term);
    797 StrLiteral:
    798 
    799                     if( baseType.IsObject() || baseType.IsNull() ){
     791                if( (term[0]=='e'||term[0]=='E')
     792                    && (term[1]=='x'||term[1]=='X')
     793                    && term[2]=='\"'
     794                    || term[0] == '\"' )
     795                {
     796                    if( baseType.IsObject() || baseType.IsNull() )
     797                    {
    800798                        //要求タイプがオブジェクト、または未定のとき
    801799
    … …  
    814812                    }
    815813
     814                    bool isEx = true;
     815                    if( term[0] == '\"' )
     816                    {
     817                        isEx = false;
     818                    }
     819
     820                    if( isEx )
     821                    {
     822                        // 拡張版リテラル文字列（エスケープシーケンス可能）
     823                        if(!RemoveStringQuotes(term+2)){
     824                            SetError(43,NULL,cp);
     825                            goto error;
     826                        }
     827                        i3=FormatString_EscapeSequence(term+2);
     828                        term+=2;
     829                    }
     830                    else
     831                    {
     832                        // 通常文字列
     833                        if(!RemoveStringQuotes(term)){
     834                            SetError(43,NULL,cp);
     835                            goto error;
     836                        }
     837                        i3=lstrlen(term);
     838                    }
     839StrLiteral:
     840
    816841                    type_stack[sp]=typeOfPtrChar;
    817842                    bLiteralCalculation=0;
    … …  
    827852                    }
    828853                }
    829                 else if((term[0]=='e'||term[0]=='E')&&
    830                     (term[1]=='x'||term[1]=='X')&&
    831                     term[2]=='\"'){
    832                     //拡張版リテラル文字列（エスケープシーケンス可能）
    833                     if(!RemoveStringQuotes(term+2)){
    834                         SetError(43,NULL,cp);
    835                         goto error;
    836                     }
    837                     i3=FormatString_EscapeSequence(term+2);
    838                     term+=2;
    839 
    840                     goto StrLiteral;
    841                 }
    842854                else if(IsVariableTopChar(term[0])||
    843855                    term[0]=='*'||
    844                     (term[0]=='.'&&IsVariableTopChar(term[1]))){
     856                    (term[0]=='.'&&IsVariableTopChar(term[1])))
     857                {
    845858                    //////////////////
    846859                    // 何らかの識別子
    … …  
    938951                            //リテラル文字列
    939952
     953                            if( baseType.IsObject() || baseType.IsNull() )
     954                            {
     955                                //要求タイプがオブジェクト、または未定のとき
     956
     957                                //String型オブジェクトを生成
     958                                NewStringObject(UseReg,term);
     959
     960                                type_stack[sp]=DEF_OBJECT;
     961                                index_stack[sp]=(LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr();
     962                                bLiteralCalculation=0;
     963
     964                                if(bXmm) pobj_reg->LockXmmReg();
     965                                else pobj_reg->LockReg();
     966
     967                                sp++;
     968                                break;
     969                            }
     970
    940971                            double dbl = compiler.GetObjectModule().meta.GetGlobalConsts().GetDoubleData(term);
    941972                            memcpy(&i64data,&dbl,sizeof(double));
    … …  
    961992                            goto Literal;
    962993                        }
    963                         /*else if(i3==DEF_STRING){
    964                             //リテラル文字列
    965 
    966                             //バイト数
    967                             i3=(int)dbl;
    968 
    969                             memcpy(term,temporary,i3);
    970                             goto StrLiteral;
    971                         }*/
    972994                        else{
    973995                            SetError(1,NULL,0);

  • trunk/abdev/BasicCompiler_Common/ParamImpl.cpp

    r290 r319  
    4242                for(i++,i2++;;i++,i2++){
    4343                    temporary[i2]=buffer[i];
     44                    if( buffer[i] == '\0' )
     45                    {
     46                        SetError();
     47                        break;
     48                    }
    4449                    if(buffer[i]=='\"') break;
    4550                }

  • trunk/abdev/BasicCompiler_Common/Subroutine.cpp

    r316 r319  
    494494    pSub_System_Call_Destructor_of_GlobalObject->CompleteCompile();
    495495
     496    // _System_CGarbageCollection.RegisterGlobalRootsは一番最後にコンパイル
     497    extern const UserProc *pUserProc_System_CGarbageCollection_RegisterGlobalRoots;
     498    pUserProc_System_CGarbageCollection_RegisterGlobalRoots->CompleteCompile();
     499
    496500repeat:
    497501    compiler.GetObjectModule().meta.GetUserProcs().Iterator_Reset();
    … …  
    531535        pSub_System_Call_Destructor_of_GlobalObject->KillCompileStatus();
    532536        CompileBufferInProcedure( *pSub_System_Call_Destructor_of_GlobalObject );
    533     }
    534 }
     537
     538        // _System_CGarbageCollection.RegisterGlobalRootsは一番最後にコンパイル
     539        pUserProc_System_CGarbageCollection_RegisterGlobalRoots->KillCompileStatus();
     540        CompileBufferInProcedure( *pUserProc_System_CGarbageCollection_RegisterGlobalRoots );
     541    }
     542}
Note: See TracChangeset for help on using the changeset viewer.