Changeset 308 in dev for trunk/abdev/BasicCompiler64


Ignore:
Timestamp:
Aug 29, 2007, 9:05:22 AM (17 years ago)
Author:
dai_9181
Message:

静的リンクライブラリにより、複数のグローバル領域が存在することになったのでそれぞれを関数ベースに分けた

Location:
trunk/abdev/BasicCompiler64
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • trunk/abdev/BasicCompiler64/BasicCompiler.vcproj

    r270 r308  
    8282                Name="VCLinkerTool"
    8383                AdditionalOptions="/MACHINE:AMD64"
    84                 AdditionalDependencies="comctl32.lib psapi.lib bufferoverflowu.lib commond.lib smoothied.lib"
     84                AdditionalDependencies="comctl32.lib psapi.lib bufferoverflowu.lib commond.lib smoothied.lib imagehlp.lib"
    8585                OutputFile="../ActiveBasic/BasicCompiler64.exe"
    8686                LinkIncremental="2"
    … …  
    194194                Name="VCLinkerTool"
    195195                AdditionalOptions="/MACHINE:AMD64"
    196                 AdditionalDependencies="comctl32.lib psapi.lib bufferoverflowu.lib common.lib smoothie.lib"
     196                AdditionalDependencies="comctl32.lib psapi.lib bufferoverflowu.lib common.lib smoothie.lib imagehlp.lib"
    197197                OutputFile="../ActiveBasic/BasicCompiler64.exe"
    198198                LinkIncremental="1"
    … …  
    412412                    </File>
    413413                </Filter>
     414                <Filter
     415                    Name="Low Level Classes"
     416                    >
     417                    <File
     418                        RelativePath="..\BasicCompiler_Common\include\StackFrame.h"
     419                        >
     420                    </File>
     421                </Filter>
    414422            </Filter>
    415423        </Filter>
    … …  
    502510                        <Tool
    503511                            Name="VCCLCompilerTool"
    504                             UsePrecompiledHeader="0"
     512                            UsePrecompiledHeader="2"
    505513                            BrowseInformation="0"
    506514                        />
    … …  
    511519                        <Tool
    512520                            Name="VCCLCompilerTool"
    513                             UsePrecompiledHeader="0"
     521                            UsePrecompiledHeader="2"
    514522                            BrowseInformation="0"
    515523                        />
    … …  
    524532                        <Tool
    525533                            Name="VCCLCompilerTool"
    526                             UsePrecompiledHeader="0"
     534                            UsePrecompiledHeader="2"
    527535                            BrowseInformation="0"
    528536                        />
    … …  
    533541                        <Tool
    534542                            Name="VCCLCompilerTool"
    535                             UsePrecompiledHeader="0"
     543                            UsePrecompiledHeader="2"
    536544                            BrowseInformation="0"
    537545                        />
    … …  
    546554                        <Tool
    547555                            Name="VCCLCompilerTool"
    548                             UsePrecompiledHeader="0"
     556                            UsePrecompiledHeader="2"
    549557                            BrowseInformation="0"
    550558                        />
    … …  
    555563                        <Tool
    556564                            Name="VCCLCompilerTool"
    557                             UsePrecompiledHeader="0"
     565                            UsePrecompiledHeader="2"
    558566                            BrowseInformation="0"
    559567                        />
    … …  
    568576                        <Tool
    569577                            Name="VCCLCompilerTool"
    570                             UsePrecompiledHeader="0"
     578                            UsePrecompiledHeader="2"
    571579                            BrowseInformation="0"
    572580                        />
    … …  
    577585                        <Tool
    578586                            Name="VCCLCompilerTool"
    579                             UsePrecompiledHeader="0"
     587                            UsePrecompiledHeader="2"
    580588                            BrowseInformation="0"
    581589                        />
    … …  
    593601                            <Tool
    594602                                Name="VCCLCompilerTool"
    595                                 UsePrecompiledHeader="0"
    596                                 BrowseInformation="0"
    597                             />
    598                         </FileConfiguration>
    599                         <FileConfiguration
    600                             Name="Release|Win32"
    601                             >
    602                             <Tool
    603                                 Name="VCCLCompilerTool"
    604                                 UsePrecompiledHeader="0"
     603                                UsePrecompiledHeader="2"
     604                                BrowseInformation="0"
     605                            />
     606                        </FileConfiguration>
     607                        <FileConfiguration
     608                            Name="Release|Win32"
     609                            >
     610                            <Tool
     611                                Name="VCCLCompilerTool"
     612                                UsePrecompiledHeader="2"
    605613                                BrowseInformation="0"
    606614                            />
    … …  
    615623                            <Tool
    616624                                Name="VCCLCompilerTool"
    617                                 UsePrecompiledHeader="0"
    618                                 BrowseInformation="0"
    619                             />
    620                         </FileConfiguration>
    621                         <FileConfiguration
    622                             Name="Release|Win32"
    623                             >
    624                             <Tool
    625                                 Name="VCCLCompilerTool"
    626                                 UsePrecompiledHeader="0"
     625                                UsePrecompiledHeader="2"
     626                                BrowseInformation="0"
     627                            />
     628                        </FileConfiguration>
     629                        <FileConfiguration
     630                            Name="Release|Win32"
     631                            >
     632                            <Tool
     633                                Name="VCCLCompilerTool"
     634                                UsePrecompiledHeader="2"
    627635                                BrowseInformation="0"
    628636                            />
    … …  
    637645                            <Tool
    638646                                Name="VCCLCompilerTool"
    639                                 UsePrecompiledHeader="0"
    640                                 BrowseInformation="0"
    641                             />
    642                         </FileConfiguration>
    643                         <FileConfiguration
    644                             Name="Release|Win32"
    645                             >
    646                             <Tool
    647                                 Name="VCCLCompilerTool"
    648                                 UsePrecompiledHeader="0"
     647                                UsePrecompiledHeader="2"
     648                                BrowseInformation="0"
     649                            />
     650                        </FileConfiguration>
     651                        <FileConfiguration
     652                            Name="Release|Win32"
     653                            >
     654                            <Tool
     655                                Name="VCCLCompilerTool"
     656                                UsePrecompiledHeader="2"
    649657                                BrowseInformation="0"
    650658                            />
    … …  
    654662                        RelativePath=".\increment.cpp"
    655663                        >
     664                        <FileConfiguration
     665                            Name="Debug|Win32"
     666                            >
     667                            <Tool
     668                                Name="VCCLCompilerTool"
     669                                UsePrecompiledHeader="2"
     670                            />
     671                        </FileConfiguration>
     672                        <FileConfiguration
     673                            Name="Release|Win32"
     674                            >
     675                            <Tool
     676                                Name="VCCLCompilerTool"
     677                                UsePrecompiledHeader="2"
     678                            />
     679                        </FileConfiguration>
    656680                    </File>
    657681                    <File
    … …  
    663687                            <Tool
    664688                                Name="VCCLCompilerTool"
    665                                 UsePrecompiledHeader="0"
    666                                 BrowseInformation="0"
    667                             />
    668                         </FileConfiguration>
    669                         <FileConfiguration
    670                             Name="Release|Win32"
    671                             >
    672                             <Tool
    673                                 Name="VCCLCompilerTool"
    674                                 UsePrecompiledHeader="0"
     689                                UsePrecompiledHeader="2"
     690                                BrowseInformation="0"
     691                            />
     692                        </FileConfiguration>
     693                        <FileConfiguration
     694                            Name="Release|Win32"
     695                            >
     696                            <Tool
     697                                Name="VCCLCompilerTool"
     698                                UsePrecompiledHeader="2"
    675699                                BrowseInformation="0"
    676700                            />
    … …  
    685709                            <Tool
    686710                                Name="VCCLCompilerTool"
    687                                 UsePrecompiledHeader="0"
    688                                 BrowseInformation="0"
    689                             />
    690                         </FileConfiguration>
    691                         <FileConfiguration
    692                             Name="Release|Win32"
    693                             >
    694                             <Tool
    695                                 Name="VCCLCompilerTool"
    696                                 UsePrecompiledHeader="0"
     711                                UsePrecompiledHeader="2"
     712                                BrowseInformation="0"
     713                            />
     714                        </FileConfiguration>
     715                        <FileConfiguration
     716                            Name="Release|Win32"
     717                            >
     718                            <Tool
     719                                Name="VCCLCompilerTool"
     720                                UsePrecompiledHeader="2"
    697721                                BrowseInformation="0"
    698722                            />
    … …  
    707731                            <Tool
    708732                                Name="VCCLCompilerTool"
    709                                 UsePrecompiledHeader="0"
    710                                 BrowseInformation="0"
    711                             />
    712                         </FileConfiguration>
    713                         <FileConfiguration
    714                             Name="Release|Win32"
    715                             >
    716                             <Tool
    717                                 Name="VCCLCompilerTool"
    718                                 UsePrecompiledHeader="0"
     733                                UsePrecompiledHeader="2"
     734                                BrowseInformation="0"
     735                            />
     736                        </FileConfiguration>
     737                        <FileConfiguration
     738                            Name="Release|Win32"
     739                            >
     740                            <Tool
     741                                Name="VCCLCompilerTool"
     742                                UsePrecompiledHeader="2"
    719743                                BrowseInformation="0"
    720744                            />
    … …  
    729753                            <Tool
    730754                                Name="VCCLCompilerTool"
    731                                 UsePrecompiledHeader="0"
    732                                 BrowseInformation="0"
    733                             />
    734                         </FileConfiguration>
    735                         <FileConfiguration
    736                             Name="Release|Win32"
    737                             >
    738                             <Tool
    739                                 Name="VCCLCompilerTool"
    740                                 UsePrecompiledHeader="0"
     755                                UsePrecompiledHeader="2"
     756                                BrowseInformation="0"
     757                            />
     758                        </FileConfiguration>
     759                        <FileConfiguration
     760                            Name="Release|Win32"
     761                            >
     762                            <Tool
     763                                Name="VCCLCompilerTool"
     764                                UsePrecompiledHeader="2"
    741765                                BrowseInformation="0"
    742766                            />
    … …  
    751775                            <Tool
    752776                                Name="VCCLCompilerTool"
    753                                 UsePrecompiledHeader="0"
    754                                 BrowseInformation="0"
    755                             />
    756                         </FileConfiguration>
    757                         <FileConfiguration
    758                             Name="Release|Win32"
    759                             >
    760                             <Tool
    761                                 Name="VCCLCompilerTool"
    762                                 UsePrecompiledHeader="0"
     777                                UsePrecompiledHeader="2"
     778                                BrowseInformation="0"
     779                            />
     780                        </FileConfiguration>
     781                        <FileConfiguration
     782                            Name="Release|Win32"
     783                            >
     784                            <Tool
     785                                Name="VCCLCompilerTool"
     786                                UsePrecompiledHeader="2"
    763787                                BrowseInformation="0"
    764788                            />
    … …  
    772796                        RelativePath=".\Compile_Interface.cpp"
    773797                        >
     798                        <FileConfiguration
     799                            Name="Debug|Win32"
     800                            >
     801                            <Tool
     802                                Name="VCCLCompilerTool"
     803                                UsePrecompiledHeader="2"
     804                            />
     805                        </FileConfiguration>
     806                        <FileConfiguration
     807                            Name="Release|Win32"
     808                            >
     809                            <Tool
     810                                Name="VCCLCompilerTool"
     811                                UsePrecompiledHeader="2"
     812                            />
     813                        </FileConfiguration>
    774814                    </File>
    775815                    <File
    776816                        RelativePath=".\Compile_Object.cpp"
    777817                        >
     818                        <FileConfiguration
     819                            Name="Debug|Win32"
     820                            >
     821                            <Tool
     822                                Name="VCCLCompilerTool"
     823                                UsePrecompiledHeader="2"
     824                            />
     825                        </FileConfiguration>
     826                        <FileConfiguration
     827                            Name="Release|Win32"
     828                            >
     829                            <Tool
     830                                Name="VCCLCompilerTool"
     831                                UsePrecompiledHeader="2"
     832                            />
     833                        </FileConfiguration>
    778834                    </File>
    779835                </Filter>
    … …  
    789845                            <Tool
    790846                                Name="VCCLCompilerTool"
    791                                 UsePrecompiledHeader="0"
    792                                 BrowseInformation="0"
    793                             />
    794                         </FileConfiguration>
    795                         <FileConfiguration
    796                             Name="Release|Win32"
    797                             >
    798                             <Tool
    799                                 Name="VCCLCompilerTool"
    800                                 UsePrecompiledHeader="0"
     847                                UsePrecompiledHeader="2"
     848                                BrowseInformation="0"
     849                            />
     850                        </FileConfiguration>
     851                        <FileConfiguration
     852                            Name="Release|Win32"
     853                            >
     854                            <Tool
     855                                Name="VCCLCompilerTool"
     856                                UsePrecompiledHeader="2"
    801857                                BrowseInformation="0"
    802858                            />
    … …  
    811867                            <Tool
    812868                                Name="VCCLCompilerTool"
     869                                UsePrecompiledHeader="2"
    813870                                ObjectFile="$(IntDir)\$(InputName)1.obj"
    814871                                XMLDocumentationFileName="$(IntDir)\$(InputName)1.xdc"
    … …  
    820877                            <Tool
    821878                                Name="VCCLCompilerTool"
     879                                UsePrecompiledHeader="2"
    822880                                ObjectFile="$(IntDir)\$(InputName)1.obj"
    823881                                XMLDocumentationFileName="$(IntDir)\$(InputName)1.xdc"
    … …  
    828886                        RelativePath=".\stack_frame.cpp"
    829887                        >
     888                        <FileConfiguration
     889                            Name="Debug|Win32"
     890                            >
     891                            <Tool
     892                                Name="VCCLCompilerTool"
     893                                UsePrecompiledHeader="2"
     894                            />
     895                        </FileConfiguration>
     896                        <FileConfiguration
     897                            Name="Release|Win32"
     898                            >
     899                            <Tool
     900                                Name="VCCLCompilerTool"
     901                                UsePrecompiledHeader="2"
     902                            />
     903                        </FileConfiguration>
    830904                    </File>
    831905                </Filter>
    … …  
    836910                        RelativePath=".\CLockParameter.cpp"
    837911                        >
     912                        <FileConfiguration
     913                            Name="Debug|Win32"
     914                            >
     915                            <Tool
     916                                Name="VCCLCompilerTool"
     917                                UsePrecompiledHeader="2"
     918                            />
     919                        </FileConfiguration>
     920                        <FileConfiguration
     921                            Name="Release|Win32"
     922                            >
     923                            <Tool
     924                                Name="VCCLCompilerTool"
     925                                UsePrecompiledHeader="2"
     926                            />
     927                        </FileConfiguration>
    838928                    </File>
    839929                    <File
    840930                        RelativePath=".\Compile_CallProc.cpp"
    841931                        >
     932                        <FileConfiguration
     933                            Name="Debug|Win32"
     934                            >
     935                            <Tool
     936                                Name="VCCLCompilerTool"
     937                                UsePrecompiledHeader="2"
     938                            />
     939                        </FileConfiguration>
     940                        <FileConfiguration
     941                            Name="Release|Win32"
     942                            >
     943                            <Tool
     944                                Name="VCCLCompilerTool"
     945                                UsePrecompiledHeader="2"
     946                            />
     947                        </FileConfiguration>
    842948                    </File>
    843949                    <File
    … …  
    849955                            <Tool
    850956                                Name="VCCLCompilerTool"
    851                                 UsePrecompiledHeader="0"
    852                                 BrowseInformation="0"
    853                             />
    854                         </FileConfiguration>
    855                         <FileConfiguration
    856                             Name="Release|Win32"
    857                             >
    858                             <Tool
    859                                 Name="VCCLCompilerTool"
    860                                 UsePrecompiledHeader="0"
     957                                UsePrecompiledHeader="2"
     958                                BrowseInformation="0"
     959                            />
     960                        </FileConfiguration>
     961                        <FileConfiguration
     962                            Name="Release|Win32"
     963                            >
     964                            <Tool
     965                                Name="VCCLCompilerTool"
     966                                UsePrecompiledHeader="2"
    861967                                BrowseInformation="0"
    862968                            />
    … …  
    871977                            <Tool
    872978                                Name="VCCLCompilerTool"
    873                                 UsePrecompiledHeader="0"
    874                                 BrowseInformation="0"
    875                             />
    876                         </FileConfiguration>
    877                         <FileConfiguration
    878                             Name="Release|Win32"
    879                             >
    880                             <Tool
    881                                 Name="VCCLCompilerTool"
    882                                 UsePrecompiledHeader="0"
     979                                UsePrecompiledHeader="2"
     980                                BrowseInformation="0"
     981                            />
     982                        </FileConfiguration>
     983                        <FileConfiguration
     984                            Name="Release|Win32"
     985                            >
     986                            <Tool
     987                                Name="VCCLCompilerTool"
     988                                UsePrecompiledHeader="2"
    883989                                BrowseInformation="0"
    884990                            />
    … …  
    888994                        RelativePath=".\CParameter.cpp"
    889995                        >
     996                        <FileConfiguration
     997                            Name="Debug|Win32"
     998                            >
     999                            <Tool
     1000                                Name="VCCLCompilerTool"
     1001                                UsePrecompiledHeader="2"
     1002                            />
     1003                        </FileConfiguration>
     1004                        <FileConfiguration
     1005                            Name="Release|Win32"
     1006                            >
     1007                            <Tool
     1008                                Name="VCCLCompilerTool"
     1009                                UsePrecompiledHeader="2"
     1010                            />
     1011                        </FileConfiguration>
    8901012                    </File>
    8911013                    <File
    8921014                        RelativePath=".\OperatorProc.cpp"
    8931015                        >
     1016                        <FileConfiguration
     1017                            Name="Debug|Win32"
     1018                            >
     1019                            <Tool
     1020                                Name="VCCLCompilerTool"
     1021                                UsePrecompiledHeader="2"
     1022                            />
     1023                        </FileConfiguration>
     1024                        <FileConfiguration
     1025                            Name="Release|Win32"
     1026                            >
     1027                            <Tool
     1028                                Name="VCCLCompilerTool"
     1029                                UsePrecompiledHeader="2"
     1030                            />
     1031                        </FileConfiguration>
    8941032                    </File>
    8951033                </Filter>
    … …  
    11011239                            Name="VCCLCompilerTool"
    11021240                            AdditionalOptions="/bigobj"
     1241                            UsePrecompiledHeader="0"
    11031242                        />
    11041243                    </FileConfiguration>
    … …  
    11091248                            Name="VCCLCompilerTool"
    11101249                            AdditionalOptions="/bigobj"
     1250                            UsePrecompiledHeader="0"
    11111251                        />
    11121252                    </FileConfiguration>
    11131253                </File>
    1114                 <Filter
    1115                     Name="Core Classes"
    1116                     >
    1117                     <File
    1118                         RelativePath="..\BasicCompiler_Common\src\CommonCodeGenerator.cpp"
    1119                         >
    1120                     </File>
    1121                 </Filter>
    11221254            </Filter>
    11231255            <Filter
    … …  
    11441276                    </File>
    11451277                    <File
     1278                        RelativePath="..\BasicCompiler_Common\src\CommonCodeGenerator.cpp"
     1279                        >
     1280                    </File>
     1281                    <File
    11461282                        RelativePath="..\BasicCompiler_Common\src\Const.cpp"
    11471283                        >
    … …  
    11771313                    <File
    11781314                        RelativePath="..\BasicCompiler_Common\src\NativeCode.cpp"
     1315                        >
     1316                    </File>
     1317                    <File
     1318                        RelativePath="..\BasicCompiler_Common\src\ObjectModule.cpp"
    11791319                        >
    11801320                    </File>

  • trunk/abdev/BasicCompiler64/CParameter.cpp

    r226 r308  
    348348                else if( dummyType.IsWhole() ){
    349349                    //実数型 → 整数型
    350                     ChangeTypeToWhole(calcType.GetBasicType(),dummyType.GetBasicType(),reg,temp_reg);
     350                    ChangeTypeToWhole(calcType,dummyType,reg,temp_reg);
    351351                }
    352352            }
    … …  
    376376                if( calcType.IsReal() ){
    377377                    //実数型 → 整数型
    378                     ChangeTypeToWhole( calcType.GetBasicType(), DEF_QWORD,reg,temp_reg);
     378                    ChangeTypeToWhole( calcType, Type(DEF_QWORD), reg, temp_reg );
    379379                }
    380380            }

  • trunk/abdev/BasicCompiler64/CodeGenerator.cpp

    r262 r308  
    128128        }
    129129
    130         pNativeCode->Put( disp, scheduleType );
     130        pNativeCode->PutEx( disp, scheduleType );
    131131    }
    132132
    … …  
    176176
    177177    //即値
    178     pNativeCode->Put( i32data, scheduleType );
     178    pNativeCode->PutEx( i32data, scheduleType );
    179179}
    180180void CodeGenerator::op_mov_RV64(int reg,_int64 i64data){
    … …  
    247247            pPertialSchedule = pertialSchedules.back();
    248248        }
    249         pNativeCode->Put( offset, scheduleType );
     249        pNativeCode->PutEx( offset, scheduleType );
    250250    }
    251251    else{
    … …  
    320320            pPertialSchedule = pertialSchedules.back();
    321321        }
    322         pNativeCode->Put( offset, scheduleType );
     322        pNativeCode->PutEx( offset, scheduleType );
    323323    }
    324324    else{
    … …  
    645645        pPertialSchedule = pertialSchedules.back();
    646646    }
    647     pNativeCode->Put( offset, scheduleType );
     647    pNativeCode->PutEx( offset, scheduleType );
    648648
    649649    return pPertialSchedule;

  • trunk/abdev/BasicCompiler64/Compile_Calc.cpp

    r266 r308  
    99#include "Opcode.h"
    1010
    11 void SetVariableFromRax(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar){
     11void SetVariableFromRax( const Type &varType, int CalcType,RELATIVE_VAR *pRelativeVar){
    1212    /////////////////////////////////////////////////
    1313    // raxの内容を変数にコピーするコードを抽出
    1414    /////////////////////////////////////////////////
    1515
    16     if(VarType==DEF_BOOLEAN){
     16    if( varType.IsBoolean() )
     17    {
    1718        //bool
    1819        SetBooleanVariable(CalcType,pRelativeVar);
    1920    }
    20     else if( IsRealNumberType( VarType ) ){
     21    else if( varType.IsReal() )
     22    {
    2123        // Double/Single型変数へレジスタの値を代入
    22         SetRealVariable(VarType, CalcType, pRelativeVar);
    23     }
    24     else if( IsWholeNumberType( VarType ) || VarType == DEF_OBJECT ){
    25         int typeSize = GetTypeSize( VarType, -1 );
    26 
     24        SetRealVariable(varType.GetBasicType(), CalcType, pRelativeVar);
     25    }
     26    else if( varType.IsWhole() || varType.IsObject() )
     27    {
    2728        //整数変数へraxの値を格納する
    28         SetWholeVariable( typeSize, CalcType, pRelativeVar );
     29        SetWholeVariable( varType.GetSize(), CalcType, pRelativeVar );
    2930    }
    3031    else{
    … …  
    265266    // rax（実数はxmm0）の内容を変数にコピー
    266267    /////////////////////////////////////////////////
    267     SetVariableFromRax(varType.GetBasicType(),calcType.GetBasicType(),&VarRelativeVar);
     268    SetVariableFromRax(varType,calcType.GetBasicType(),&VarRelativeVar);
    268269}

  • trunk/abdev/BasicCompiler64/Compile_Calc_PushVar.cpp

    r254 r308  
    125125
    126126
    127 void SetReg_WholeVariable(int type,RELATIVE_VAR *pRelativeVar,int reg){
    128     int varSize;
    129 
    130     varSize=GetTypeSize(type,-1);
     127void SetReg_WholeVariable( const Type &type, RELATIVE_VAR *pRelativeVar,int reg)
     128{
     129    int varSize = type.GetSize();
    131130
    132131    if(pRelativeVar->dwKind==VAR_GLOBAL){

  • trunk/abdev/BasicCompiler64/Compile_CallProc.cpp

    r304 r308  
    8989}
    9090
    91 bool Opcode_CallProc(const char *Parameter,const UserProc *pUserProc,DWORD dwFlags,const char *ObjectName,int RefType){
    92     // TODO: RefTypeは不必要なので削除する
     91bool Opcode_CallProc(const char *Parameter,const UserProc *pUserProc,DWORD dwFlags,const char *ObjectName){
    9392    int i2;
    9493
    … …  
    131130                Type varType;
    132131                GetVarType( ObjectName, varType, false );
    133                 pobj_c = &varType.GetClass();
    134                 if( NATURAL_TYPE( varType.GetBasicType() ) != DEF_OBJECT ){
     132                if( NATURAL_TYPE( varType.GetBasicType() ) == DEF_OBJECT )
     133                {
     134                    pobj_c = &varType.GetClass();
     135                    leftType = varType;
     136                }
     137                else
     138                {
    135139                    pobj_c=compiler.GetObjectModule().meta.GetClasses().Find(ObjectName);
    136140                    if( pobj_c ){

  • trunk/abdev/BasicCompiler64/Compile_Func.cpp

    r266 r308  
    108108
    109109        char ObjectName[VN_SIZE];
    110         int RefType;
    111         SplitObjectName(name,ObjectName,&RefType);
     110        ReferenceKind referenceKind;
     111        SplitObjectName(name,ObjectName, referenceKind );
    112112
    113113        if(ObjectName[0]){
    … …  
    120120
    121121                //参照タイプが整合しているかをチェック
    122                 if(type.GetBasicType()!=RefType) SetError(104,ObjectName,cp);
     122                if( !( type.IsObject() && referenceKind == RefDot
     123                    || type.IsObjectPtr() && referenceKind == RefPointer ) )
     124                {
     125                    SetError(104,ObjectName,cp);
     126                }
    123127
    124128                if(type.IsObjectPtr()){
    … …  
    166170void Opcode_Func_SizeOf( const string &typeName ){
    167171    Type tempType;
    168     if( !Compiler::StringToType( typeName, tempType ) ){
     172    if( !compiler.StringToType( typeName, tempType ) ){
    169173        SetError(3,typeName,cp);
    170174        return;
    … …  
    268272    else{
    269273        //mov rax,ptr[rax]
    270         compiler.codeGenerator.op_mov_RM(GetTypeSize(type,-1),REG_RAX,REG_RAX,0,MOD_BASE);
     274        compiler.codeGenerator.op_mov_RM(Type(type).GetSize(),REG_RAX,REG_RAX,0,MOD_BASE);
    271275    }
    272276}

  • trunk/abdev/BasicCompiler64/Compile_Object.cpp

    r263 r308  
    5151    Opcode_CallProc(CreateParameter,
    5252        pUserProc,
    53         PROCFLAG_NEW,"",0);
     53        PROCFLAG_NEW,"");
    5454
    5555    {
    … …  
    6464            Opcode_CallProc(temporary,
    6565                subs[0],
    66                 PROCFLAG_NEW,"",0);
     66                PROCFLAG_NEW,"");
    6767        }
    6868        else{

  • trunk/abdev/BasicCompiler64/Compile_ProcOp.cpp

    r266 r308  
    182182    else bDebugSupportProc=0;
    183183
    184     pUserProc->_beginOpAddressOld = obp;
    185 
    186184    //コンパイル中の関数が属するクラス
    187185    compiler.pCompilingClass=pUserProc->GetParentClassPtr();
    … …  
    211209
    212210        //スタックフレーム管理用オブジェクトを初期化
    213         extern CStackFrame *pobj_sf;
    214         pobj_sf=new CStackFrame();
     211        extern StackFrame *pobj_sf;
     212        pobj_sf=new StackFrame();
    215213
    216214        SystemProc(*pUserProc);
    … …  
    220218        pobj_sf=0;
    221219
    222         pUserProc->_endOpAddressOld = obp;
    223220        return;
    224221    }
    … …  
    232229    //プロシージャ抜け出しスケジュール（Exit Sub/Function）
    233230    compiler.codeGenerator.exitSubCodePositions.clear();
    234     compiler.codeGenerator._exitSubCodePositions_ObpOld.clear();
    235231
    236232    //ラベル用のメモリを確保
    … …  
    260256
    261257    //レキシカルスコープ情報を初期化
    262     compiler.codeGenerator.lexicalScopes.Init(obp);
     258    compiler.codeGenerator.lexicalScopes.Init( compiler.codeGenerator.GetNativeCodeSize() );
    263259
    264260
    … …  
    271267        Parameter &param = *pUserProc->RealParams()[i3];
    272268
    273         Variable *pVar = new Variable( param.GetVarName(), param, false, param.IsRef(), "" );
     269        Variable *pVar = new Variable( param.GetVarName(), param, false, param.IsRef(), "", false );
    274270
    275271        if( param.IsArray() ){
    … …  
    307303
    308304    //スタックフレーム管理用クラスを初期化
    309     extern CStackFrame *pobj_sf;
    310     pobj_sf=new CStackFrame();
     305    extern StackFrame *pobj_sf;
     306    pobj_sf=new StackFrame();
    311307
    312308
    … …  
    390386        else{
    391387            if( pUserProc->ReturnType().IsObject() ){
    392                 sprintf(temporary,"%s=Nothing%c%c%s",temp,1,ESC_AS, Compiler::TypeToString( pUserProc->ReturnType() ).c_str() );
     388                sprintf(temporary,"%s=Nothing%c%c%s",temp,1,ESC_AS, compiler.TypeToString( pUserProc->ReturnType() ).c_str() );
    393389            }
    394390            else{
    395391                //戻り値用の変数の定義
    396                 sprintf(temporary,"%s%c%c%s",temp,1,ESC_AS, Compiler::TypeToString( pUserProc->ReturnType() ).c_str() );
     392                sprintf(temporary,"%s%c%c%s",temp,1,ESC_AS, compiler.TypeToString( pUserProc->ReturnType() ).c_str() );
    397393            }
    398394
    … …  
    477473                        &compiler.pCompilingClass->GetSuperClass().GetConstructorMethod()->GetUserProc(),
    478474                        0,
    479                         "",
    480                         0);
     475                        "");
    481476                }
    482477            }
    … …  
    553548                        &method->GetUserProc(),
    554549                        0,
    555                         "",
    556                         0);
     550                        "");
    557551                }
    558552            }
    … …  
    612606        else if(IsWholeNumberType(i3)){
    613607            //整数型
    614             SetReg_WholeVariable(i3,&RelativeVar,REG_RAX);
     608            SetReg_WholeVariable(Type(i3),&RelativeVar,REG_RAX);
    615609        }
    616610        else SetError(300,NULL,cp);
    … …  
    666660    delete pobj_sf;
    667661    pobj_sf=0;
    668 
    669 
    670     pUserProc->_endOpAddressOld = obp;
    671662
    672663

  • trunk/abdev/BasicCompiler64/Compile_Set_Var.cpp

    r254 r308  
    249249
    250250    //cmp rax,0
    251     compiler.codeGenerator.op_cmp_value(GetTypeSize(type,-1),REG_RAX,0);
     251    compiler.codeGenerator.op_cmp_value(Type(type).GetSize(),REG_RAX,0);
    252252
    253253    //setne al

  • trunk/abdev/BasicCompiler64/Compile_Statement.cpp

    r266 r308  
    8080            }
    8181
    82             Opcode_CallProc("",pUserProc,0,"",0);
     82            Opcode_CallProc("",pUserProc,0,"");
    8383
    8484            return;
    … …  
    199199
    200200    //レキシカルスコープをレベルアップ
    201     compiler.codeGenerator.lexicalScopes.Start( obp, LexicalScope::SCOPE_TYPE_IF );
     201    compiler.codeGenerator.lexicalScopes.Start(
     202        compiler.codeGenerator.GetNativeCodeSize(),
     203        LexicalScope::SCOPE_TYPE_IF
     204    );
    202205
    203206    int i2=CompileBuffer(ESC_ENDIF,0);
    … …  
    220223
    221224        //レキシカルスコープをレベルアップ
    222         compiler.codeGenerator.lexicalScopes.Start( obp, LexicalScope::SCOPE_TYPE_IF );
     225        compiler.codeGenerator.lexicalScopes.Start(
     226            compiler.codeGenerator.GetNativeCodeSize(),
     227            LexicalScope::SCOPE_TYPE_IF
     228        );
    223229
    224230        CompileBuffer(ESC_ENDIF,0);
    … …  
    277283        {
    278284            //jmp ...
    279             extern int obp;
    280             compiler.codeGenerator.op_jmp( i-obp, sizeof(long), false, true );
     285            compiler.codeGenerator.op_jmp(
     286                i-compiler.codeGenerator.GetNativeCodeSize(),
     287                sizeof(long),
     288                false,
     289                true
     290            );
    281291        }
    282292    }
    … …  
    293303        {
    294304            //jmp ...
    295             extern int obp;
    296             compiler.codeGenerator.op_jmp( i-obp, sizeof(long), false, true );
     305            compiler.codeGenerator.op_jmp(
     306                i-compiler.codeGenerator.GetNativeCodeSize(),
     307                sizeof(long),
     308                false,
     309                true
     310            );
    297311        }
    298312    }
    … …  
    313327
    314328    //レキシカルスコープをレベルアップ
    315     compiler.codeGenerator.lexicalScopes.Start( obp, LexicalScope::SCOPE_TYPE_WHILE );
     329    compiler.codeGenerator.lexicalScopes.Start( compiler.codeGenerator.GetNativeCodeSize(), LexicalScope::SCOPE_TYPE_WHILE );
    316330
    317331    //While内をコンパイル
    … …  
    431445
    432446    //レキシカルスコープをレベルアップ
    433     compiler.codeGenerator.lexicalScopes.Start( obp, LexicalScope::SCOPE_TYPE_FOR );
     447    compiler.codeGenerator.lexicalScopes.Start( compiler.codeGenerator.GetNativeCodeSize(), LexicalScope::SCOPE_TYPE_FOR );
    434448
    435449    //For内をコンパイル
    … …  
    467481
    468482    //レキシカルスコープをレベルアップ
    469     compiler.codeGenerator.lexicalScopes.Start( obp, LexicalScope::SCOPE_TYPE_DO );
     483    compiler.codeGenerator.lexicalScopes.Start( compiler.codeGenerator.GetNativeCodeSize(), LexicalScope::SCOPE_TYPE_DO );
    470484
    471485    //Do内をコンパイル
    … …  
    743757
    744758                        //cmp reg2,r14
    745                         compiler.codeGenerator.op_cmp_reg(GetTypeSize(i2,-1),reg2,REG_R14);
     759                        compiler.codeGenerator.op_cmp_reg(Type(i2).GetSize(),reg2,REG_R14);
    746760                    }
    747761
    … …  
    767781
    768782    //レキシカルスコープをレベルアップ
    769     compiler.codeGenerator.lexicalScopes.Start( obp, LexicalScope::SCOPE_TYPE_SELECT );
     783    compiler.codeGenerator.lexicalScopes.Start( compiler.codeGenerator.GetNativeCodeSize(), LexicalScope::SCOPE_TYPE_SELECT );
    770784
    771785    //Select Case内をコンパイル
    … …  
    909923    }
    910924    else{
    911         ChangeTypeToWhole(resultType.GetBasicType(),type,REG_RCX,temp_reg);
     925        ChangeTypeToWhole(resultType,Type(type),REG_RCX,temp_reg);
    912926
    913927        //mov ptr[reg_ptr],rcx
    914         compiler.codeGenerator.op_mov_MR(GetTypeSize(type,-1),REG_RCX,reg_ptr,0,MOD_BASE);
    915     }
    916 }
     928        compiler.codeGenerator.op_mov_MR(Type(type).GetSize(),REG_RCX,reg_ptr,0,MOD_BASE);
     929    }
     930}

  • trunk/abdev/BasicCompiler64/Compile_Var.cpp

    r266 r308  
    2424    /////////////////////////////////////////////
    2525
    26     SetReg_WholeVariable(DEF_INT64,pRelativeVar,REG_R11);
     26    SetReg_WholeVariable(Type(DEF_INT64),pRelativeVar,REG_R11);
    2727
    2828    //mov qword ptr[rsp+offset],r11     ※スタックフレームを利用
    … …  
    376376    RelativeVar.offset=-LocalVar_ThisPtrOffset;
    377377
    378     SetReg_WholeVariable(DEF_PTR_VOID,&RelativeVar,reg);
     378    SetReg_WholeVariable(Type(DEF_PTR_VOID),&RelativeVar,reg);
    379379}
    380380bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType, Subscripts *pResultSubscripts ){
    … …  
    742742
    743743bool SetInitGlobalData(int offset,const Type &type,const Subscripts &subscripts,const char *lpszInitBuf){
    744     extern BYTE *initGlobalBuf;
    745744    int i2,i3;
    746745    char temporary[VN_SIZE];
    … …  
    846845
    847846    if( type.IsDouble() ){
    848         *(double *)(initGlobalBuf+offset)=(double)dbl;
     847        compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.Overwrite(
     848            offset,
     849            (const char *)&dbl,
     850            sizeof(double)
     851        );
    849852    }
    850853    else if( type.IsSingle() ){
    851         *(float *)(initGlobalBuf+offset)=(float)dbl;
     854        float flt = (float)dbl;
     855        compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.Overwrite(
     856            offset,
     857            (const char *)&flt,
     858            sizeof(float)
     859        );
    852860    }
    853861    else if( type.Is64() || type.IsPointer() ){
    … …  
    867875        }
    868876        else{
    869             *(_int64 *)(initGlobalBuf+offset)=i64data;
     877            compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.Overwrite(
     878                offset,
     879                (const char *)&i64data,
     880                sizeof(_int64)
     881            );
    870882        }
    871883    }
    872884    else if( type.IsDWord() || type.IsLong() ){
    873         *(DWORD *)(initGlobalBuf+offset)=(DWORD)i64data;
     885        long l = (long)i64data;
     886        compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.Overwrite(
     887            offset,
     888            (const char *)&l,
     889            sizeof(long)
     890        );
    874891    }
    875892    else if( type.IsWord() || type.IsInteger() ){
    876         *(WORD *)(initGlobalBuf+offset)=(WORD)i64data;
     893        short s = (short)i64data;
     894        compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.Overwrite(
     895            offset,
     896            (const char *)&s,
     897            sizeof(short)
     898        );
    877899    }
    878900    else if( type.IsSByte() || type.IsByte() || type.IsBoolean() ){
    879         *(BYTE *)(initGlobalBuf+offset)=(BYTE)i64data;
     901        char c = (char)i64data;
     902        compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.Overwrite(
     903            offset,
     904            (const char *)&c,
     905            sizeof(char)
     906        );
    880907    }
    881908
    … …  
    10571084}
    10581085
    1059 void dim( char *VarName, const Subscripts &subscripts, Type &type,const char *InitBuf,const char *ConstractParameter,DWORD dwFlags){
     1086void dim( char *VarName, const Subscripts &subscripts, const Type &type,const char *InitBuf,const char *ConstractParameter,DWORD dwFlags)
     1087{
    10601088    if( UserProc::IsGlobalAreaCompiling() ){
    10611089        /////////////////////////
    … …  
    10781106        bool isConst = ( dwFlags & DIMFLAG_CONST ) ? true:false;
    10791107
    1080         Variable *pVar = new Variable( VarName, type, isConst, false, ConstractParameter );
     1108        Variable *pVar = new Variable( VarName, type, isConst, false, ConstractParameter, false );
    10811109
    10821110        if( subscripts.size() > 0 ){
    … …  
    11941222            SetError();
    11951223        }
    1196         SetVariableFromRax( DEF_OBJECT, DEF_OBJECT, &RelativeVar );
     1224        SetVariableFromRax( Type( DEF_OBJECT, *compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr() ), DEF_OBJECT, &RelativeVar );
    11971225    }
    11981226}
    … …  
    12961324            // call AddGlobalRootPtr
    12971325            compiler.codeGenerator.op_call( pUserProc_AddGlobalRootPtr );
    1298 
    1299             ReallocNativeCodeBuffer();
    13001326        }
    13011327    }

  • trunk/abdev/BasicCompiler64/MakePeHdr.cpp

    r268 r308  
    22
    33#include <jenga/include/common/Environment.h>
     4#include <jenga/include/common/Path.h>
     5#include <jenga/include/common/Directory.h>
    46
    57#include <jenga/include/smoothie/Smoothie.h>
    … …  
    2931    *pSub_System_InitStaticLocalVariables,
    3032    *pSub_System_Call_Destructor_of_GlobalObject,
     33    *pSub_System_End,
    3134    *pSub_System_GetSp,
    3235    *pSub_pow,
    … …  
    8891
    8992
    90 void DebugVariable(void){
    91     char temporary[255];
    92     sprintf(temporary,"_DebugSys_dwThreadID[255]%c%cDWord",1,ESC_AS);
    93     OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
    94     sprintf(temporary,"_DebugSys_ProcNum[255]%c%cDWord",1,ESC_AS);
    95     OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
    96     sprintf(temporary,"_DebugSys_lplpObp[255]%c%c*ULONG_PTR",1,ESC_AS);
    97     OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
    98     sprintf(temporary,"_DebugSys_lplpSpBase[255]%c%c*ULONG_PTR",1,ESC_AS);
    99     OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
    100 }
    101 
    10293void Compile(void){
    10394    extern HWND hMainDlg;
    … …  
    158149    // 名前空間情報を取得
    159150    NamespaceSupporter::CollectNamespaces(
    160         compiler.source.GetBuffer(),
     151        compiler.GetObjectModule().GetCurrentSource().GetBuffer(),
    161152        compiler.GetObjectModule().meta.GetNamespaces()
    162153    );
    … …  
    165156    //   CollectProcedures関数の中で参照されるオブジェクト名を事前に取得する。
    166157    //     ※オブジェクトの内容までは取得しない
    167     compiler.GetObjectModule().meta.GetClasses().CollectClassesForNameOnly( compiler.source );
     158    compiler.GetObjectModule().meta.GetClasses().CollectClassesForNameOnly( compiler.GetObjectModule().GetCurrentSource() );
    168159
    169160    //TypeDef情報を初期化
    170     compiler.GetObjectModule().meta.GetTypeDefs().Init();
     161    compiler.GetObjectModule().meta.GetTypeDefs().CollectTypeDefs();
    171162
    172163    //定数情報を取得
    … …  
    176167    compiler.pCompilingClass = NULL;
    177168    CollectProcedures(
    178         compiler.source,
     169        compiler.GetObjectModule().GetCurrentSource(),
    179170        compiler.GetObjectModule().meta.GetUserProcs(),
    180171        compiler.GetObjectModule().meta.GetDllProcs()
    … …  
    262253    }
    263254
     255    if(pSub_System_End=GetSubHash("_System_End",1)){
     256        pSub_System_End->Using();
     257    }
     258
    264259    if(pSub_System_GetSp=GetSubHash("_System_GetSp",1)){
    265260        pSub_System_GetSp->Using();
    … …  
    298293    }
    299294
    300 
    301 
    302     //データテーブルスケジュール
    303     pobj_DataTableSchedule=new CSchedule();
    304     pobj_DataTableSchedule->SetFlag(SCHEDULE_FLAG_RELOC);
    305 
    306     //インポートテーブルスケジュール
    307     //※x64はRPI（実行中アドレス）からのオフセットになるため、再配置が不要
    308     pobj_ImportAddrSchedule=new CImportAddrSchedule();
    309 
    310     //プロシージャポインタスケジュール
    311     pobj_SubAddrSchedule=new CSubAddrSchedule();
    312 
    313     //グローバル変数アドレススケジュール
    314     pobj_GlobalVarSchedule=new CSchedule();
    315     pobj_GlobalVarSchedule->SetFlag(SCHEDULE_FLAG_RELOC);
    316 
    317     //グローバル変数の初期バッファ
    318     extern BYTE *initGlobalBuf;
    319     initGlobalBuf=(BYTE *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,1);
    320 
    321295    //リロケーション情報
    322296    pobj_Reloc=new CReloc();
    323297
    324     obp_AllocSize=8192*2;
    325     OpBuffer=(char *)calloc(obp_AllocSize,1);
    326     obp=0;
    327 
    328298    //レジスタのブロッキングを管理するためのオブジェクトを生成
    329299    pobj_BlockReg=new CBlockReg;
    330300
    331301    //レキシカルスコープ情報を初期化
    332     compiler.codeGenerator.lexicalScopes.Init(obp);
     302    compiler.codeGenerator.lexicalScopes.Init(0);
    333303
    334304
    … …  
    373343        compiler.codeGenerator.ClearContinueArea();
    374344
    375         //スタックフレーム管理用クラスを初期化
    376         extern CStackFrame *pobj_sf;
    377         pobj_sf=new CStackFrame();
     345        //スタックフレーム管理用クラスを選択
     346        pobj_sf = &compiler.GetObjectModule().globalStackFrame;
    378347
    379348        // コード生成対象を選択
    … …  
    386355        //breakpoint;
    387356
    388         //sub rsp,スタックフレームサイズ
    389         const PertialSchedule *pStackFramePertialSchedule = compiler.codeGenerator.op_sub_rsp( 0, true );
    390 
    391         if(bDebugCompile){
    392             //デバッグ用の変数を定義
    393             DebugVariable();
    394         }
    395 
    396         //GC用の変数を定義
    397         InitGCVariables();
    398 
    399         //_System_StartupProgramの呼び出し
    400         compiler.codeGenerator.op_call(pSub_System_StartupProgram);
     357        if( compiler.IsCore() )
     358        {
     359            //sub rsp,スタックフレームサイズ
     360            const PertialSchedule *pStackFramePertialSchedule = compiler.codeGenerator.op_sub_rsp( 0, true );
     361
     362            if(bDebugCompile){
     363                //デバッグ用の変数を定義
     364                DebugVariable();
     365            }
     366
     367            //GC用の変数を定義
     368            InitGCVariables();
     369
     370            //_System_StartupProgramの呼び出し
     371            compiler.codeGenerator.op_call(pSub_System_StartupProgram);
     372        }
    401373
    402374        //クラスに属する静的メンバを定義
    … …  
    419391
    420392
    421         ///////////////////////////////////////
    422         // グローバル文字列変数の解放処理
    423         ///////////////////////////////////////
    424 
    425         //call _System_Call_Destructor_of_GlobalObject
    426         extern const UserProc *pSub_System_Call_Destructor_of_GlobalObject;
    427         compiler.codeGenerator.op_call(pSub_System_Call_Destructor_of_GlobalObject);
    428 
    429 
    430         //add rsp,スタックフレームサイズ
    431         int stackFrameSize = pobj_sf->GetFrameSize(0);
    432         compiler.codeGenerator.op_add_RV( REG_RSP, stackFrameSize );
    433 
    434         //xor rax,rax（raxを0に初期化する）
    435         compiler.codeGenerator.op_zero_reg(REG_RAX);
    436 
    437         //ret
    438         compiler.codeGenerator.op_ret();
     393        if( !compiler.IsStaticLibrary() )
     394        {
     395            ///////////////////////////////////////
     396            // グローバル文字列変数の解放処理
     397            ///////////////////////////////////////
     398
     399            //call _System_End
     400            extern const UserProc *pSub_System_End;
     401            compiler.codeGenerator.op_call(pSub_System_End);
     402
     403
     404            //add rsp,スタックフレームサイズ
     405            int stackFrameSize = pobj_sf->GetFrameSize(0);
     406            compiler.codeGenerator.op_add_RV( REG_RSP, stackFrameSize );
     407
     408            //xor rax,rax（raxを0に初期化する）
     409            compiler.codeGenerator.op_zero_reg(REG_RAX);
     410
     411            //ret
     412            compiler.codeGenerator.op_ret();
     413
     414            //スタックフレームスケジュール（subコマンドに渡す値）
     415            compiler.codeGenerator.opfix( pStackFramePertialSchedule, stackFrameSize );
     416
     417            //スタックフレームスケジュールを実行
     418            pobj_sf->RunningSchedule( stackFrameSize );
     419            pobj_sf=0;
     420        }
    439421
    440422        //グローバル実行領域のコードサイズ
    441423        extern int GlobalOpBufferSize;
    442         GlobalOpBufferSize=obp;
    443 
    444         //スタックフレームスケジュール（subコマンドに渡す値）
    445         compiler.codeGenerator.opfix( pStackFramePertialSchedule, stackFrameSize );
    446 
    447         //スタックフレームスケジュールを実行
    448         pobj_sf->RunningSchedule( stackFrameSize );
    449         delete pobj_sf;
    450         pobj_sf=0;
     424        GlobalOpBufferSize = compiler.linker.GetNativeCode().GetSize();
    451425
    452426        //With情報のメモリを解放
    … …  
    504478    trace( "コード生成が終了しました。" );
    505479
    506     vector<ObjectModule *> masterObjectModules;
    507     masterObjectModules.push_back( &compiler.GetObjectModule() );
    508     compiler.linker.Link( masterObjectModules );
     480
     481    if( compiler.IsStaticLibrary() )
     482    {
     483        // 静的リンクライブラリ
     484
     485        // 格納先ディレクトリを作る
     486        Jenga::Common::Path path( OutputFileName );
     487        Jenga::Common::Directory dir( path.GetDriveName() + path.GetDirName(), true );
     488
     489        // 書き込む
     490        if( !compiler.GetObjectModule().Write( OutputFileName ) )
     491        {
     492            MessageBox(0,"XML書き込みに失敗","test",0);
     493        }
     494        return;
     495    }
     496
     497    extern BOOL bError;
     498    if( !bError )
     499    {
     500        CompileMessage( "リンク中..." );
     501    }
     502
     503
     504    compiler.linker.Link( compiler.GetObjectModule() );
     505
     506    extern SourceLines oldSourceLines;
     507    oldSourceLines = compiler.linker.GetNativeCode().GetSourceLines();
     508
     509
     510    /////////////////////////////////////////////////////////////////
     511    // vtblの構築
     512    /////////////////////////////////////////////////////////////////
     513
     514    compiler.GetObjectModule().meta.GetClasses().GenerateVTables();
     515
    509516
    510517
    … …  
    525532
    526533        if( !pDllProc->IsUsing() ){
    527             pDllProc=pDllProc->pNextData;
    528534            continue;
    529535        }
    … …  
    619625
    620626            if( pUserProc->GetName() == "DllMain" ){
    621                 DllMain_EntryPoint=pUserProc->_beginOpAddressOld;
     627                DllMain_EntryPoint = pUserProc->GetBeginOpAddress();
    622628            }
    623629
    624630            lpdwExportAddressTable=(DWORD *)HeapReAlloc(hHeap,0,lpdwExportAddressTable,(ExportNum+1)*sizeof(DWORD));
    625             lpdwExportAddressTable[ExportNum]=pUserProc->_beginOpAddressOld;
     631            lpdwExportAddressTable[ExportNum] = pUserProc->GetBeginOpAddress();
    626632
    627633            lpdwExportNamePointerTable=(DWORD *)HeapReAlloc(hHeap,0,lpdwExportNamePointerTable,(ExportNum+1)*sizeof(DWORD));
    … …  
    703709
    704710        if( !pDllProc->IsUsing() ){
    705             pDllProc=pDllProc->pNextData;
    706711            continue;
    707712        }
    … …  
    742747
    743748            if( !pDllProc->IsUsing() ){
    744                 pDllProc=pDllProc->pNextData;
    745749                continue;
    746750            }
    … …  
    780784
    781785            if( !pDllProc->IsUsing() ){
    782                 pDllProc=pDllProc->pNextData;
    783786                continue;
    784787            }
    … …  
    855858
    856859    //コードセッションのファイル上のサイズ
    857     if(obp%FILE_ALIGNMENT) FileSize_CodeSection=obp+(FILE_ALIGNMENT-obp%FILE_ALIGNMENT);
    858     else FileSize_CodeSection=obp;
     860    if(compiler.linker.GetNativeCode().GetSize()%FILE_ALIGNMENT)
     861    {
     862        FileSize_CodeSection =
     863            compiler.linker.GetNativeCode().GetSize()
     864            + (FILE_ALIGNMENT-compiler.linker.GetNativeCode().GetSize()%FILE_ALIGNMENT);
     865    }
     866    else
     867    {
     868        FileSize_CodeSection = compiler.linker.GetNativeCode().GetSize();
     869    }
    859870    if(FileSize_CodeSection) bUse_CodeSection=1;
    860871    else bUse_CodeSection=0;
    … …  
    10521063
    10531064            if( !pDllProc->IsUsing() ){
    1054                 pDllProc=pDllProc->pNextData;
    10551065                continue;
    10561066            }
    … …  
    10701080
    10711081
    1072     //////////////////////////////
    1073     // データテーブルスケジュール
    1074     for(i=0;i<pobj_DataTableSchedule->num;i++){
    1075         *((long *)(OpBuffer+pobj_DataTableSchedule->pObpValues[i]))+=ImageBase+MemPos_DataSection;
    1076     }
    1077     delete pobj_DataTableSchedule;
    1078 
    1079 
    1080     //////////////////////////////////
    1081     // インポートテーブルスケジュール（インポート アドレス テーブルを指し示させる）
    1082     // ※x86はRVAからのオフセット。x64はRPI（実行中アドレス）からのオフセット
    1083     for(i=0;i<pobj_ImportAddrSchedule->num;i++){
    1084         const DllProc *pDllProc = pobj_ImportAddrSchedule->ppdi[i];
    1085         *((long *)(OpBuffer+pobj_ImportAddrSchedule->pObpValues[i]))=
    1086             MemPos_ImportSection+
    1087             pDllProc->GetLookupAddress()
    1088             -(MemPos_CodeSection+pobj_ImportAddrSchedule->pObpValues[i]+sizeof(long));
    1089     }
    1090     delete pobj_ImportAddrSchedule;
    1091 
    1092 
    1093     ////////////////////////////////////
    1094     // プロシージャポインタスケジュール
    1095     for(i=0;i<pobj_SubAddrSchedule->num;i++){
    1096         if(pobj_SubAddrSchedule->ppsi[i]->_beginOpAddressOld==0
    1097             &&pobj_SubAddrSchedule->ppsi[i]->_endOpAddressOld==0){
    1098             SetError(300,NULL,-1);
    1099         }
    1100 
    1101         if(pobj_SubAddrSchedule->pbCall[i]){
    1102             *((long *)(OpBuffer+pobj_SubAddrSchedule->pObpValues[i]))=
    1103                 pobj_SubAddrSchedule->ppsi[i]->_beginOpAddressOld-(pobj_SubAddrSchedule->pObpValues[i]+sizeof(long));
    1104         }
    1105         else{
    1106             *((long *)(OpBuffer+pobj_SubAddrSchedule->pObpValues[i]))=
    1107                 pobj_SubAddrSchedule->ppsi[i]->_beginOpAddressOld+ImageBase+MemPos_CodeSection;
    1108         }
    1109     }
    1110     delete pobj_SubAddrSchedule;
    1111 
    1112 
    11131082    if( compiler.IsDll() ){
    11141083        //DLLの場合はリロケーション情報を生成
    11151084        pobj_Reloc->ResetRelocBuffer();
    11161085    }
    1117 
    1118 
    1119 
    1120     //////////////////////////////////////
    1121     // グローバル変数アドレススケジュール
    1122     //////////////////////////////////////
    1123 
    1124     /*
    1125     GlobalArea1 - 初期バッファあり
    1126     GlobalArea2 - 初期バッファなし
    1127     */
    1128     for(i=0;i<pobj_GlobalVarSchedule->num;i++){
    1129         if(*((long *)(OpBuffer+pobj_GlobalVarSchedule->pObpValues[i])) & 0x80000000){
    1130             //初期バッファなし
    1131             *((long *)(OpBuffer+pobj_GlobalVarSchedule->pObpValues[i]))=
    1132                 AllInitGlobalVarSize+
    1133                 (*((long *)(OpBuffer+pobj_GlobalVarSchedule->pObpValues[i])) & 0x7FFFFFFF)+
    1134                 ImageBase+MemPos_RWSection;
    1135         }
    1136         else{
    1137             //初期バッファあり
    1138             *((long *)(OpBuffer+pobj_GlobalVarSchedule->pObpValues[i]))+=
    1139                 ImageBase+MemPos_RWSection;
    1140         }
    1141     }
    1142     delete pobj_GlobalVarSchedule;
    1143 
    11441086
    11451087
    … …  
    11491091    compiler.linker.ResolveUserProcSchedules( MemPos_CodeSection );
    11501092    compiler.linker.ResolveGlobalVarSchedules( MemPos_RWSection );
    1151 
    1152     if( obp == compiler.linker.GetNativeCode().GetSize() )
    1153     {
    1154         memcpy( OpBuffer, compiler.linker.GetNativeCode().GetCodeBuffer(), compiler.linker.GetNativeCode().GetSize() );
    1155     }
    1156     else
    1157     {
    1158         SetError();
    1159     }
     1093    compiler.linker.ResolveVtblSchedule( MemPos_DataSection );
    11601094
    11611095
    … …  
    13491283    memset((char *)CodeSectionHeader.Name,0,IMAGE_SIZEOF_SHORT_NAME);
    13501284    lstrcpy((char *)CodeSectionHeader.Name,".text");
    1351     CodeSectionHeader.Misc.VirtualSize=         obp;
     1285    CodeSectionHeader.Misc.VirtualSize=         MemSize_CodeSection;
    13521286    CodeSectionHeader.VirtualAddress=           MemPos_CodeSection; //開始アドレス
    13531287    CodeSectionHeader.SizeOfRawData=            FileSize_CodeSection;
    … …  
    15461480
    15471481    //コード
    1548     WriteFile(hFile,OpBuffer,obp,(DWORD *)&i2,NULL);
     1482    WriteFile(
     1483        hFile,
     1484        compiler.linker.GetNativeCode().GetBuffer(),
     1485        compiler.linker.GetNativeCode().GetSize(),
     1486        (DWORD *)&i2,
     1487        NULL
     1488    );
    15491489    i+=i2;
    15501490
    … …  
    16291569    if(bUse_RWSection){
    16301570        //リライタブル データ テーブル（グローバル変数の初期バッファ）
    1631         initGlobalBuf=(BYTE *)HeapReAlloc(hHeap,
    1632             HEAP_ZERO_MEMORY,
    1633             initGlobalBuf,
    1634             FileSize_RWSection);
    1635         WriteFile(hFile,initGlobalBuf,FileSize_RWSection,(DWORD *)&i2,NULL);
    1636         i+=i2;
     1571        char *temp = (char *)calloc( FileSize_RWSection, 1 );
     1572        memcpy(
     1573            temp,
     1574            compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.GetBuffer(),
     1575            compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.GetSize()
     1576        );
     1577
     1578        WriteFile(hFile,temp,FileSize_RWSection,(DWORD *)&i2,NULL);
     1579        i+=i2;
     1580
     1581        free( temp );
    16371582    }
    16381583
    … …  
    17091654    HeapDefaultFree(pHintTable);
    17101655
    1711     //グローバル変数の初期バッファを解放
    1712     HeapDefaultFree(initGlobalBuf);
    1713 
    1714     //コードバッファを解放
    1715     free(OpBuffer);
    1716     OpBuffer=0;
    1717 
    17181656    //リソースセクションバッファを解放
    17191657    HeapDefaultFree(RSrcSectionBuffer);

  • trunk/abdev/BasicCompiler64/NumOpe.cpp

    r266 r308  
    112112    else if( resultType.IsWhole() || resultType.IsObject()){
    113113        //整数型
    114         SetReg_WholeVariable(resultType.GetBasicType(),&relativeVar,UseReg);
     114        SetReg_WholeVariable(resultType,&relativeVar,UseReg);
    115115    }
    116116    else if( resultType.IsStruct() ){
    … …  
    132132    return true;
    133133}
    134 bool TermMemberOpe( const CClass &objClass, const Type &baseType, Type &resultType, const char *termFull, const char *termLeft, const char *member ){
     134bool TermMemberOpe( const Type &leftType, const Type &baseType, Type &resultType, const char *termFull, const char *termLeft, const char *member )
     135{
     136    const CClass &objClass = leftType.GetClass();
    135137
    136138    int UseReg=pobj_reg->GetNextReg();
    … …  
    138140
    139141
    140     if( GetMemberType( objClass, member, resultType, 0, false ) ){
     142    if( GetMemberType( leftType, member, resultType, 0, false ) ){
    141143        // メンバが見つかったとき
    142144
    … …  
    192194                pobj_sf->push( UseReg );
    193195
    194                 if( !Opcode_CallProc(parameter,pUserProc,PROCFLAG_NEW,termLeft,0 ) ){
     196                if( !Opcode_CallProc(parameter,pUserProc,PROCFLAG_NEW,termLeft ) ){
    195197                    //レジスタ資源を復元
    196198                    RESTORE_REGISTER_RESOURCE
    … …  
    284286        }
    285287
    286         return TermMemberOpe( leftType.GetClass(), baseType, resultType, termFull, termLeft, member );
     288        return TermMemberOpe( leftType, baseType, resultType, termFull, termLeft, member );
    287289    }
    288290globalArea:
    … …  
    463465    ////////////////////////////////
    464466
    465     if( Compiler::StringToType( termFull, resultType ) ){
     467    if( compiler.StringToType( termFull, resultType ) ){
    466468        resultType.SetBasicType( resultType.GetBasicType() | FLAG_CAST );
    467469        return true;
    … …  
    767769                    // As演算子の右辺値
    768770                    //型名
    769                     if( Compiler::StringToType( term, resultType ) ){
     771                    if( compiler.StringToType( term, resultType ) ){
    770772                        resultType.SetBasicType( resultType.GetBasicType() | FLAG_CAST );
    771773                    }

  • trunk/abdev/BasicCompiler64/NumOpe_Arithmetic.cpp

    r266 r308  
    667667
    668668        //shl reg1,cl
    669         compiler.codeGenerator.op_shl_reg(GetTypeSize(type[sp-2],-1),reg1);
     669        compiler.codeGenerator.op_shl_reg(Type(type[sp-2]).GetSize(),reg1);
    670670    }
    671671    else if(idCalc==CALC_SHR){
    … …  
    674674
    675675            //sar
    676             compiler.codeGenerator.op_sar_reg(GetTypeSize(type[sp-2],-1),reg1);
     676            compiler.codeGenerator.op_sar_reg(Type(type[sp-2]).GetSize(),reg1);
    677677        }
    678678        else{
    … …  
    680680
    681681            //shr
    682             compiler.codeGenerator.op_shr_reg(GetTypeSize(type[sp-2],-1),reg1);
     682            compiler.codeGenerator.op_shr_reg(Type(type[sp-2]).GetSize(),reg1);
    683683        }
    684684    }

  • trunk/abdev/BasicCompiler64/NumOpe_Logical.cpp

    r226 r308  
    101101
    102102        //cmp reg,0
    103         compiler.codeGenerator.op_cmp_value(GetTypeSize(type[sp-1],-1),reg,0);
     103        compiler.codeGenerator.op_cmp_value(Type(type[sp-1]).GetSize(),reg,0);
    104104
    105105        //setne al

  • trunk/abdev/BasicCompiler64/NumOpe_TypeOperation.cpp

    r266 r308  
    88#include "Opcode.h"
    99
    10 void ExtendTypeTo64(int type,int reg){
    11     if(type==DEF_LONG){
     10void ExtendTypeTo64( const Type &oldType, int reg ){
     11    if( oldType.IsLong() )
     12    {
    1213        //movsxd reg64,reg32
    1314        compiler.codeGenerator.op_movsxd(reg,reg);
    1415    }
    15     else if(type==DEF_DWORD){
     16    else if( oldType.IsDWord() )
     17    {
    1618        //and reg,00000000FFFFFFFFh
    1719    }
    18     else if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){
     20    else if( oldType.IsInteger() )
     21    {
    1922        //movsx reg64,reg16
    2023        compiler.codeGenerator.op_movsx64_FromReg16(reg,reg);
    2124    }
    22     else if(type==DEF_WORD){
     25    else if( oldType.IsWord() )
     26    {
    2327        //and reg,000000000000FFFFh
    2428        compiler.codeGenerator.op_and64_value(reg,(int)0xFFFF);
    2529    }
    26     else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
     30    else if( oldType.IsSByte() )
     31    {
    2732        //movsx reg64,reg8
    2833        compiler.codeGenerator.op_movsx64_FromReg8(reg,reg);
    2934    }
    30     else if(type==DEF_BYTE || type==DEF_BOOLEAN){
     35    else if( oldType.IsByte() || oldType.IsBoolean() )
     36    {
    3137        //and reg,00000000000000FFh
    3238        compiler.codeGenerator.op_and64_value(reg,(int)0x00FF);
    3339    }
    3440}
    35 void ExtendTypeTo32(int type,int reg){
    36     if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){
     41void ExtendTypeTo32( const Type &oldType, int reg ){
     42    if( oldType.IsInteger() )
     43    {
    3744        //movsx reg32,reg16
    3845        compiler.codeGenerator.op_movsx32_FromReg16(reg,reg);
    3946    }
    40     else if(type==DEF_WORD){
     47    else if( oldType.IsWord() )
     48    {
    4149        //and reg,0000FFFFh
    4250        compiler.codeGenerator.op_and32_value(reg,(int)0xFFFF);
    4351    }
    44     else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
     52    else if( oldType.IsSByte() )
     53    {
    4554        //movsx reg32,reg8
    4655        compiler.codeGenerator.op_movsx32_FromReg8(reg,reg);
    4756    }
    48     else if(type==DEF_BYTE || type==DEF_BOOLEAN){
     57    else if( oldType.IsByte() || oldType.IsBoolean() )
     58    {
    4959        //and reg,000000FFh
    5060        compiler.codeGenerator.op_and32_value(reg,(int)0xFF);
    5161    }
    5262}
    53 void ExtendTypeTo16(int type,int reg){
    54     if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
     63void ExtendTypeTo16( const Type &oldType, int reg ){
     64    if( oldType.IsSByte() )
     65    {
    5566        //movsx reg16,reg8
    5667        compiler.codeGenerator.op_movsx16_FromReg8(reg,reg);
    5768    }
    58     else if(type==DEF_BYTE){
     69    else if( oldType.IsByte() || oldType.IsBoolean() )
     70    {
    5971        //and reg,000000FFh
    6072        compiler.codeGenerator.op_and32_value(reg,(int)0xFF);
    … …  
    183195}
    184196
    185 void ChangeTypeToWhole(int OldType,int NewType,int reg,int xmm_reg){
    186     if(OldType==DEF_DOUBLE){
    187         if(Is64Type(NewType)){
     197void ChangeTypeToWhole( const Type &oldType, const Type &newType, int reg, int xmm_reg )
     198{
     199    if( oldType.IsDouble() )
     200    {
     201        if( newType.Is64() )
     202        {
    188203            //cvttsd2si reg,xmm_reg
    189204            compiler.codeGenerator.op_cvttsd2si_xmm(sizeof(_int64),reg,xmm_reg);
    190205        }
    191         else{
     206        else
     207        {
    192208            //cvttsd2si reg,xmm_reg
    193209            compiler.codeGenerator.op_cvttsd2si_xmm(sizeof(long),reg,xmm_reg);
    194210        }
    195211    }
    196     else if(OldType==DEF_SINGLE){
    197         if(Is64Type(NewType)){
     212    if( oldType.IsSingle() )
     213    {
     214        if( newType.Is64() )
     215        {
    198216            //cvttss2si reg,xmm_reg
    199217            compiler.codeGenerator.op_cvttss2si_xmm(sizeof(_int64),reg,xmm_reg);
    200218        }
    201         else{
     219        else
     220        {
    202221            //cvttss2si reg,xmm_reg
    203222            compiler.codeGenerator.op_cvttss2si_xmm(sizeof(long),reg,xmm_reg);
    … …  
    207226        //整数から整数へ変換
    208227
    209         if(Is64Type(NewType)){
    210             ExtendTypeTo64(OldType,reg);
    211         }
    212         else if(GetTypeSize(NewType,-1)==sizeof(long)){
    213             ExtendTypeTo32(OldType,reg);
    214         }
    215         else if(GetTypeSize(NewType,-1)==sizeof(short)){
    216             ExtendTypeTo16(OldType,reg);
     228        if( newType.Is64() )
     229        {
     230            ExtendTypeTo64(oldType,reg);
     231        }
     232        if( newType.GetSize() == sizeof(long) )
     233        {
     234            ExtendTypeTo32(oldType,reg);
     235        }
     236        if( newType.GetSize() == sizeof(short) )
     237        {
     238            ExtendTypeTo16(oldType,reg);
    217239        }
    218240    }
    … …  
    477499    sp=*pStackPointer;
    478500
    479     int CastType;
    480     CastType=type[sp-1];
    481     if((CastType&FLAG_CAST)==0){
     501    int castBasicType = type[sp-1];
     502    if((castBasicType&FLAG_CAST)==0){
    482503        SetError(47,NULL,cp);
    483504        return 0;
    484505    }
    485     CastType=CastType&(~FLAG_CAST);
     506    castBasicType = castBasicType&(~FLAG_CAST);
     507
     508    Type oldType( type[sp-2], index_stack[sp-2] );
     509    Type castType( castBasicType, index_stack[sp-1] );
    486510
    487511    int xmm_reg,reg;
    488 
    489     if(IsRealNumberType(CastType)){
     512    if( castType.IsReal() )
     513    {
    490514        //実数型へキャスト
    491515
    492         if(IsRealNumberType(type[sp-2])){
    493             SetOneTermToReg_RealCalc(type[sp-2],&xmm_reg);
    494         }
    495         else{
    496             if(Is64Type(type[sp-2]))
    497                 SetOneTermToReg_Whole64Calc(type[sp-2],&reg);
    498             else if(IsWholeNumberType(type[sp-2]))
    499                 SetOneTermToReg_Whole32Calc(type[sp-2],&reg);
     516        if( oldType.IsReal() )
     517        {
     518            SetOneTermToReg_RealCalc(oldType.GetBasicType(),&xmm_reg);
     519        }
     520        else
     521        {
     522            if( oldType.Is64() )
     523            {
     524                SetOneTermToReg_Whole64Calc(oldType.GetBasicType(),&reg);
     525            }
     526            else if( oldType.IsWhole() )
     527            {
     528                SetOneTermToReg_Whole32Calc(oldType.GetBasicType(),&reg);
     529            }
    500530
    501531            pobj_reg->UnlockReg();
    … …  
    504534        }
    505535
    506         if(CastType==DEF_DOUBLE){
     536        if( castType.IsDouble() )
     537        {
    507538            //Double型にデータ変換
    508             ChangeTypeToXmm_Double(type[sp-2],xmm_reg,reg);
    509         }
    510         else if(CastType==DEF_SINGLE){
     539            ChangeTypeToXmm_Double(oldType.GetBasicType(),xmm_reg,reg);
     540        }
     541        else if( castType.IsSingle() )
     542        {
    511543            //Single型にデータ変換
    512             ChangeTypeToXmm_Single(type[sp-2],xmm_reg,reg);
     544            ChangeTypeToXmm_Single(oldType.GetBasicType(),xmm_reg,reg);
    513545        }
    514546
    … …  
    521553        //その他整数型へ変換
    522554
    523         if(IsRealNumberType(type[sp-2])){
    524             SetOneTermToReg_RealCalc(type[sp-2],&xmm_reg);
     555        if( oldType.IsReal() )
     556        {
     557            SetOneTermToReg_RealCalc(oldType.GetBasicType(),&xmm_reg);
    525558
    526559            pobj_reg->UnlockXmmReg();
    … …  
    529562
    530563            //整数型へデータ変換
    531             ChangeTypeToWhole(type[sp-2],CastType,reg,xmm_reg);
     564            ChangeTypeToWhole(oldType,castType,reg,xmm_reg);
    532565
    533566            if(reg==REG_R14){
    … …  
    545578
    546579            //整数型へデータ変換
    547             ChangeTypeToWhole(type[sp-2],CastType,reg,0);
     580            ChangeTypeToWhole(oldType,castType,reg,0);
    548581
    549582            if(reg==REG_R14){
    … …  
    554587    }
    555588
    556     type[sp-2]=CastType;
    557     index_stack[sp-2]=index_stack[sp-1];
     589    type[sp-2] = castType.GetBasicType();
     590    index_stack[sp-2] = castType.GetIndex();
    558591
    559592    sp--;

  • trunk/abdev/BasicCompiler64/Opcode.h

    r263 r308  
    1616
    1717extern int cp;
    18 extern int obp;
    19 extern char *OpBuffer;
    2018
    2119#define breakpoint compiler.codeGenerator.PutOld( (char)0xCC );
    … …  
    4543
    4644
    47 class CStackFrame
    48 {
    49     ///////////////////////////
    50     // スタックフレーム管理
    51     ///////////////////////////
    52 
    53     PertialSchedules pertialSchedules;
    54 
    55     int lowest_sp;          //スタックポインタの最下位位置
    56     int now_sp;             //スタックポインタ
    57     int max_parm_size;      //パラメータの最大サイズ
    58 
    59 public:
    60     //コンストラクタ
    61     CStackFrame();
    62 
    63     //デストラクタ
    64     ~CStackFrame();
    65 
    66     int GetFrameSize( int localParamSize );
    67     int GetNowSp();
    68     void mov_sp( int reg );
    69     int push(int reg);
    70     void push(int xmm_reg,int varSize);
    71     void ref_offset_data( int reg, int sp_offset );
    72     void ref(int reg);
    73     void ref(int xmm_reg,int varSize);
    74     void pop(int reg = REG_NON);
    75     void pop(int xmm_reg,int varSize);
    76     void parameter_allocate(int size);
    77     void RunningSchedule( int stackFrameSize );
    78 
    79     void error_check(void);
    80 };
    81 extern CStackFrame *pobj_sf;
     45extern StackFrame *pobj_sf;
    8246
    8347
    … …  
    188152
    189153//Compile_Calc.cpp
    190 void SetVariableFromRax(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar);
     154void SetVariableFromRax( const Type &varType, int CalcType,RELATIVE_VAR *pRelativeVar);
    191155void OpcodeCalc(const char *Command);
    192156
    … …  
    224188
    225189//NumOpe_TypeOperation.cpp
    226 void ExtendTypeTo64(int type,int reg);
    227 void ExtendTypeTo32(int type,int reg);
    228 void ExtendTypeTo16(int type,int reg);
     190void ExtendTypeTo64( const Type &oldType, int reg );
     191void ExtendTypeTo32( const Type &oldType, int reg );
     192void ExtendTypeTo16( const Type &oldType, int reg );
    229193void ChangeTypeToXmm_Double(int type,int xmm_reg,int general_reg);
    230194void ChangeTypeToXmm_Single(int type,int xmm_reg,int general_reg);
    231 void ChangeTypeToWhole(int OldType,int NewType,int reg,int xmm_reg);
     195void ChangeTypeToWhole( const Type &oldType, const Type &newType, int reg, int xmm_reg );
    232196void SetOneTermToReg_RealCalc(int TermType,int *pXmmReg);
    233197void SetOneTermToReg_Whole64Calc(int TermType,int *pReg);
    … …  
    251215void SetXmmReg_DoubleVariable(RELATIVE_VAR *pRelativeVar,int xmm_reg);
    252216void SetXmmReg_SingleVariable(RELATIVE_VAR *pRelativeVar,int xmm_reg);
    253 void SetReg_WholeVariable(int type,RELATIVE_VAR *pRelativeVar,int reg);
     217void SetReg_WholeVariable( const Type &type, RELATIVE_VAR *pRelativeVar,int reg);
    254218
    255219//Compile_Interface.cpp
    … …  
    269233#define DIMFLAG_STATIC                  0x04
    270234#define DIMFLAG_CONST                   0x08
    271 void dim( char *VarName, const Subscripts &subscripts, Type &type, const char *InitBuf,const char *ConstractParameter,DWORD dwFlags);
     235void dim( char *VarName, const Subscripts &subscripts, const Type &type, const char *InitBuf,const char *ConstractParameter,DWORD dwFlags);
    272236void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar);
    273237bool Compile_AddGlobalRootsForGc();
    … …  
    328292#define PROCFLAG_NEW    1
    329293bool Opcode_CallProcPtr(const char *variable, const char *lpszParms,ProcPointer *pProcPointer);
    330 bool Opcode_CallProc(const char *Parameter,const UserProc *pUserProc,DWORD dwFlags,const char *ObjectName,int RefType);
     294bool Opcode_CallProc(const char *Parameter,const UserProc *pUserProc,DWORD dwFlags,const char *ObjectName);
    331295bool Opcode_CallDllProc( const char *lpszParms,DllProc *pDllProc);
    332296

  • trunk/abdev/BasicCompiler64/OperatorProc.cpp

    r226 r308  
    8484    for(int i=0;i<(int)params.size();i++){
    8585        CheckDifferentType(
    86             pUserProc->Params()[i]->GetBasicType(),
    87             pUserProc->Params()[i]->GetIndex(),
    88             params[i]->GetBasicType(),
    89             params[i]->GetIndex(),
     86            *pUserProc->Params()[i],
     87            *params[i],
    9088            "",
    9189            i);
    … …  
    9694    }
    9795
    98     int right_side_size = GetTypeSize(type_stack[sp-1],index_stack[sp-1]);
     96    int right_side_size = Type(type_stack[sp-1],index_stack[sp-1]).GetSize();
    9997
    10098    if(bTwoTerm){
    … …  
    336334    //////////////////////////////////////////////////////
    337335
    338         Opcode_CallProc(Parameter,subs[0],0,ObjectName,DEF_OBJECT);
     336        Opcode_CallProc(Parameter,subs[0],0,ObjectName);
    339337        resultType = subs[0]->ReturnType();
    340338

  • trunk/abdev/BasicCompiler64/increment.cpp

    r226 r308  
    4141    else{
    4242        reg=REG_RAX;
    43         SetReg_WholeVariable(varType.GetBasicType(),&VarRelativeVar,reg);
     43        SetReg_WholeVariable(varType,&VarRelativeVar,reg);
    4444    }
    4545
    … …  
    9494        //右辺値レジスタ
    9595        if(varType.IsDouble())
    96             ChangeTypeToXmm_Double(calcType.GetBasicType(),
     96        {
     97            ChangeTypeToXmm_Double(
     98                calcType.GetBasicType(),
    9799                pobj_reg->LockXmmReg(),
    98                 pobj_reg->GetNextReg());
     100                pobj_reg->GetNextReg()
     101            );
     102        }
    99103        else if(varType.IsSingle())
    100             ChangeTypeToXmm_Single(calcType.GetBasicType(),
     104        {
     105            ChangeTypeToXmm_Single(
     106                calcType.GetBasicType(),
    101107                pobj_reg->LockXmmReg(),
    102                 pobj_reg->GetNextReg());
     108                pobj_reg->GetNextReg()
     109            );
     110        }
    103111        else
    104             ChangeTypeToWhole(calcType.GetBasicType(),varType.GetBasicType(),
     112        {
     113            ChangeTypeToWhole(
     114                calcType,
     115                varType,
    105116                pobj_reg->LockReg(),
    106                 pobj_reg->GetNextXmmReg());
     117                pobj_reg->GetNextXmmReg()
     118            );
     119        }
    107120
    108121        int type_stack[255],sp;
    … …  
    159172    }
    160173
    161     SetVariableFromRax(varType.GetBasicType(),varType.GetBasicType(),&VarRelativeVar);
     174    SetVariableFromRax(varType,varType.GetBasicType(),&VarRelativeVar);
    162175}

  • trunk/abdev/BasicCompiler64/stack_frame.cpp

    r263 r308  
    1111/////////////////////////
    1212
    13 CStackFrame::CStackFrame(){
     13StackFrame::StackFrame(){
    1414    lowest_sp=0;
    1515    now_sp=0;
    1616    max_parm_size=0;
    1717}
    18 CStackFrame::~CStackFrame(){
     18StackFrame::~StackFrame(){
    1919    //オブジェクト破棄時に不整合がないかをチェック（バグ回避）
    2020    error_check();
    2121}
    22 int CStackFrame::GetFrameSize( int localParamSize ){
     22int StackFrame::GetFrameSize( int localParamSize ){
    2323    int answer_sp;
    2424
    … …  
    3131    return -(answer_sp-0x10);
    3232}
    33 int CStackFrame::GetNowSp(){
     33int StackFrame::GetNowSp(){
    3434    return now_sp;
    3535}
    36 void CStackFrame::mov_sp( int reg ){
     36void StackFrame::mov_sp( int reg ){
    3737    //mov reg,rsp
    3838    compiler.codeGenerator.op_mov_RR( reg, REG_RSP );
    … …  
    4343    );
    4444}
    45 int CStackFrame::push(int reg){
     45int StackFrame::push(int reg){
    4646    now_sp-=sizeof(_int64);
    4747    if(lowest_sp>now_sp) lowest_sp=now_sp;
    … …  
    5656    return now_sp;
    5757}
    58 void CStackFrame::push(int xmm_reg,int varSize){
     58void StackFrame::push(int xmm_reg,int varSize){
    5959    now_sp-=sizeof(_int64);
    6060    if(lowest_sp>now_sp) lowest_sp=now_sp;
    … …  
    7373    }
    7474}
    75 void CStackFrame::ref_offset_data( int reg, int sp_offset ){
     75void StackFrame::ref_offset_data( int reg, int sp_offset ){
    7676    //mov reg,qword ptr[rsp+offset]     ※スタックフレームを利用
    7777    pertialSchedules.push_back(
    … …  
    7979    );
    8080}
    81 void CStackFrame::ref(int reg){
     81void StackFrame::ref(int reg){
    8282    ref_offset_data( reg, now_sp );
    8383}
    84 void CStackFrame::ref(int xmm_reg,int varSize){
     84void StackFrame::ref(int xmm_reg,int varSize){
    8585    if(varSize==sizeof(double)){
    8686        //movlpd xmm_reg,qword ptr[rsp+offset]
    … …  
    9696    }
    9797}
    98 void CStackFrame::pop(int reg){
     98void StackFrame::pop(int reg){
    9999    if(reg!=REG_NON) ref(reg);
    100100
    101101    now_sp+=sizeof(_int64);
    102102}
    103 void CStackFrame::pop(int xmm_reg,int varSize){
     103void StackFrame::pop(int xmm_reg,int varSize){
    104104    ref(xmm_reg,varSize);
    105105
    106106    now_sp+=sizeof(_int64);
    107107}
    108 void CStackFrame::parameter_allocate(int size){
     108void StackFrame::parameter_allocate(int size){
    109109    if(max_parm_size<size) max_parm_size=size;
    110110}
    111 void CStackFrame::RunningSchedule( int stackFrameSize ){
     111void StackFrame::RunningSchedule( int stackFrameSize ){
    112112    BOOST_FOREACH( const PertialSchedule *pPertialSchedule, pertialSchedules )
    113113    {
    … …  
    116116}
    117117
    118 void CStackFrame::error_check(){
     118void StackFrame::error_check(){
    119119    if(now_sp){
    120120        SetError(300,NULL,cp);
    … …  
    123123
    124124//スタックフレーム管理用オブジェクトポインタ
    125 CStackFrame *pobj_sf;
     125StackFrame *pobj_sf;

  • trunk/abdev/BasicCompiler64/stdafx.h

    r218 r308  
    1717#include <boost/foreach.hpp>
    1818
     19#include <jenga/include/common/String.h>
     20
    1921#include "../BasicCompiler_Common/common.h"
     22
     23#include <Compiler.h>
Note: See TracChangeset for help on using the changeset viewer.