Changeset 50 in dev


Ignore:
Timestamp:
Feb 10, 2007, 5:44:58 PM (17 years ago)
Author:
dai_9181
Message:

オーバーロード解決用の関数保持リストを "SUBINFO " ではなく、"vector<SUBINFO *>" に変更した。

Files:
29 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler32/BasicCompiler.vcproj

    r34 r50  
    4848                Name="VCCLCompilerTool"
    4949                Optimization="0"
     50                AdditionalIncludeDirectories="..\cpplibs\boost"
    5051                PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;JPN"
    5152                MinimalRebuild="true"
    … …  
    708709                    </FileConfiguration>
    709710                </File>
    710                 <File
    711                     RelativePath="..\BasicCompiler_Common\Subroutine.cpp"
    712                     >
    713                     <FileConfiguration
    714                         Name="Debug|Win32"
    715                         >
    716                         <Tool
    717                             Name="VCCLCompilerTool"
    718                             PreprocessorDefinitions=""
    719                         />
    720                     </FileConfiguration>
    721                     <FileConfiguration
    722                         Name="Release|Win32"
    723                         >
    724                         <Tool
    725                             Name="VCCLCompilerTool"
    726                             PreprocessorDefinitions=""
    727                         />
    728                     </FileConfiguration>
    729                     <FileConfiguration
    730                         Name="English_Rel|Win32"
    731                         >
    732                         <Tool
    733                             Name="VCCLCompilerTool"
    734                             PreprocessorDefinitions=""
    735                         />
    736                     </FileConfiguration>
    737                 </File>
    738711                <Filter
    739712                    Name="Intermediate"
    … …  
    12901263                        RelativePath="..\BasicCompiler_Common\Exception.h"
    12911264                        >
     1265                    </File>
     1266                </Filter>
     1267                <Filter
     1268                    Name="Procedure"
     1269                    >
     1270                    <File
     1271                        RelativePath="..\BasicCompiler_Common\Parameter.cpp"
     1272                        >
     1273                    </File>
     1274                    <File
     1275                        RelativePath="..\BasicCompiler_Common\Subroutine.cpp"
     1276                        >
     1277                        <FileConfiguration
     1278                            Name="Debug|Win32"
     1279                            >
     1280                            <Tool
     1281                                Name="VCCLCompilerTool"
     1282                                PreprocessorDefinitions=""
     1283                            />
     1284                        </FileConfiguration>
     1285                        <FileConfiguration
     1286                            Name="Release|Win32"
     1287                            >
     1288                            <Tool
     1289                                Name="VCCLCompilerTool"
     1290                                PreprocessorDefinitions=""
     1291                            />
     1292                        </FileConfiguration>
     1293                        <FileConfiguration
     1294                            Name="English_Rel|Win32"
     1295                            >
     1296                            <Tool
     1297                                Name="VCCLCompilerTool"
     1298                                PreprocessorDefinitions=""
     1299                            />
     1300                        </FileConfiguration>
    12921301                    </File>
    12931302                </Filter>

  • BasicCompiler32/CParameter.cpp

    r47 r50  
    11#include "../BasicCompiler_Common/common.h"
    22#include "opcode.h"
    3 
    4 CParameter::CParameter(char *buffer){
    5     ///////////////////////////
    6     // パラメータ文字列を整理
    7     ///////////////////////////
    8 
    9     extern HANDLE hHeap;
    10     int i,i2,i3;
    11     char temporary[VN_SIZE];
    12 
    13     i=0;
    14     ParmsNum=0;
    15     while(1){
    16         if(buffer[i]=='\0') break;
    17 
    18         for(i2=0;;i2++,i++){
    19             if(buffer[i]=='\"'){
    20                 temporary[i2]=buffer[i];
    21                 for(i++,i2++;;i++,i2++){
    22                     temporary[i2]=buffer[i];
    23                     if(buffer[i]=='\"') break;
    24                 }
    25                 continue;
    26             }
    27 
    28             if(buffer[i]=='('){
    29                 i3=GetStringInPare(temporary+i2,buffer+i);
    30                 i2+=i3-1;
    31                 i+=i3-1;
    32                 continue;
    33             }
    34             if(buffer[i]=='['){
    35                 i3=GetStringInBracket(temporary+i2,buffer+i);
    36                 i2+=i3-1;
    37                 i+=i3-1;
    38                 continue;
    39             }
    40 
    41             if(buffer[i]==','||buffer[i]=='\0'){
    42                 temporary[i2]=0;
    43                 break;
    44             }
    45             temporary[i2]=buffer[i];
    46         }
    47 
    48         Parms[ParmsNum]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
    49         lstrcpy(Parms[ParmsNum],temporary);
    50         ParmsNum++;
    51 
    52         if(buffer[i]==',') i++;
    53     }
    54 
    55     ReturnTypeInfo.type=0;
    56     ReturnTypeInfo.u.lpIndex=0;
    57 }
    58 CParameter::CParameter(PARAMETER_INFO *pParamInfo,int ParmNum){
    59     int i;
    60     for(i=0;i<ParmNum;i++){
    61         Parms[i]=0;
    62         types[i].type=pParamInfo[i].type;
    63         types[i].u.lpIndex=pParamInfo[i].u.index;
    64     }
    65     this->ParmsNum=ParmNum;
    66 
    67     ReturnTypeInfo.type=0;
    68     ReturnTypeInfo.u.lpIndex=0;
    69 }
    70 CParameter::~CParameter(){
    71     int i2;
    72 
    73     //パラメータ文字列を解放
    74     for(i2=0;i2<ParmsNum;i2++){
    75         if(Parms[i2]==(char *)-1) continue;
    76 
    77         if(Parms[i2]) HeapDefaultFree(Parms[i2]);
    78     }
    79 }
    80 
    81 
    82 void CParameter::SetReturnType(TYPEINFO *pTypeInfo){
    83     ReturnTypeInfo=*pTypeInfo;
    84 }
    85 
    86 BOOL CParameter::_overload_check(PARAMETER_INFO *ppi,int pi_num,TYPEINFO *pReturnTypeInfo,int overload_level){
    87     //パラメータを識別してオーバーロードを解決
    88 
    89     //パラメータの個数が不一致の場合
    90     if(pi_num!=ParmsNum) return 0;
    91 
    92     int i,type;
    93     LONG_PTR lpIndex;
    94     for(i=0;i<pi_num;i++){
    95         if(Parms[i]){
    96             TYPEINFO BaseType={ppi[i].type,ppi[i].u.index};
    97             type=NumOpe_GetType(Parms[i],&BaseType,&lpIndex);
    98         }
    99         else{
    100             type=types[i].type;
    101             lpIndex=types[i].u.lpIndex;
    102         }
    103 
    104         if(type!=ppi[i].type){
    105             if(overload_level==OVERLOAD_LEVEL1){
    106                 return 0;
    107             }
    108             else if(overload_level==OVERLOAD_LEVEL2){
    109                 if(!(
    110                     IsWholeNumberType(type)&&IsWholeNumberType(ppi[i].type)||
    111                     IsRealNumberType(type)&&IsRealNumberType(ppi[i].type)
    112                     )) return 0;
    113             }
    114             else if(overload_level==OVERLOAD_LEVEL3){
    115                 if(type==DEF_OBJECT||ppi[i].type==DEF_OBJECT) return 0;
    116             }
    117         }
    118         else{
    119             if(NATURAL_TYPE(type)==DEF_OBJECT){
    120                 if(lpIndex!=ppi[i].u.index) return 0;
    121             }
    122         }
    123     }
    124 
    125     if(pReturnTypeInfo){
    126         //戻り値も比較対象にする
    127         if(ReturnTypeInfo.type==pReturnTypeInfo->type){
    128             if(NATURAL_TYPE(ReturnTypeInfo.type)==DEF_OBJECT){
    129                 if(ReturnTypeInfo.u.lpIndex != pReturnTypeInfo->u.lpIndex) return 0;
    130             }
    131         }
    132         else return 0;
    133     }
    134 
    135     return 1;
    136 }
    137 SUBINFO *CParameter::OverloadSolutionWithReturnType(const char *name,SUBINFO **ppsi,int num){
    138     int i,sw=0;
    139     SUBINFO *psi;
    140     psi=0;
    141     for(i=0;i<num;i++){
    142         psi=ppsi[i];
    143 
    144         TYPEINFO ReturnTypeInfo;
    145         ReturnTypeInfo.type=psi->ReturnType;
    146         ReturnTypeInfo.u.lpIndex=psi->u.ReturnIndex;
    147 
    148         //エラーチェック
    149         if(_overload_check(psi->pParmInfo,psi->ParmNum,&ReturnTypeInfo,OVERLOAD_LEVEL1)){
    150             if(sw){
    151                 SetError(52,name,cp);
    152                 return 0;
    153             }
    154             sw=1;
    155             break;
    156         }
    157     }
    158 
    159     if(!sw){
    160         for(i=0;i<num;i++){
    161             psi=ppsi[i];
    162 
    163             TYPEINFO ReturnTypeInfo;
    164             ReturnTypeInfo.type=psi->ReturnType;
    165             ReturnTypeInfo.u.lpIndex=psi->u.ReturnIndex;
    166 
    167             //エラーチェック
    168             if(_overload_check(psi->pParmInfo,psi->ParmNum,&ReturnTypeInfo,OVERLOAD_LEVEL2)){
    169                 if(sw){
    170                     SetError(52,name,cp);
    171                     return 0;
    172                 }
    173                 sw=1;
    174                 break;
    175             }
    176         }
    177     }
    178 
    179     if(!sw){
    180         for(i=0;i<num;i++){
    181             psi=ppsi[i];
    182 
    183             TYPEINFO ReturnTypeInfo;
    184             ReturnTypeInfo.type=psi->ReturnType;
    185             ReturnTypeInfo.u.lpIndex=psi->u.ReturnIndex;
    186 
    187             //エラーチェック
    188             if(_overload_check(psi->pParmInfo,psi->ParmNum,&ReturnTypeInfo,OVERLOAD_LEVEL3)){
    189                 if(sw){
    190                     SetError(52,name,cp);
    191                     return 0;
    192                 }
    193                 sw=1;
    194                 break;
    195             }
    196         }
    197     }
    198 
    199     if(!sw){
    200         SetError(52,name,cp);
    201         return 0;
    202     }
    203 
    204     return psi;
    205 }
    206 
    207 SUBINFO *CParameter::OverloadSolution(const char *name,SUBINFO **ppsi,int num){
    208     int i,sw=0;
    209     SUBINFO *psi;
    210     psi=0;
    211 
    212     for(i=0;i<num;i++){
    213         psi=ppsi[i];
    214 
    215         //エラーチェック
    216         if(_overload_check(psi->pParmInfo,psi->ParmNum,NULL,OVERLOAD_LEVEL1)){
    217             if(sw){
    218                 return OverloadSolutionWithReturnType(name,ppsi,num);
    219             }
    220             sw=1;
    221             break;
    222         }
    223     }
    224 
    225     if(!sw){
    226         for(i=0;i<num;i++){
    227             psi=ppsi[i];
    228 
    229             //エラーチェック
    230             if(_overload_check(psi->pParmInfo,psi->ParmNum,NULL,OVERLOAD_LEVEL2)){
    231                 if(sw){
    232                     return OverloadSolutionWithReturnType(name,ppsi,num);
    233                 }
    234                 sw=1;
    235                 break;
    236             }
    237         }
    238     }
    239 
    240     if(!sw){
    241         for(i=0;i<num;i++){
    242             psi=ppsi[i];
    243 
    244             //エラーチェック
    245             if(_overload_check(psi->pParmInfo,psi->ParmNum,NULL,OVERLOAD_LEVEL3)){
    246                 if(sw){
    247                     return OverloadSolutionWithReturnType(name,ppsi,num);
    248                 }
    249                 sw=1;
    250                 break;
    251             }
    252         }
    253     }
    254 
    255     if(!sw){
    256         SUBINFO *temp_psi;
    257         for(i=0;i<num;i++){
    258             temp_psi=ppsi[i];
    259 
    260             //エラーチェック
    261             if(temp_psi->ParmNum==this->ParmsNum){
    262                 if(sw){
    263                     sw=0;
    264                     break;
    265                 }
    266                 sw=1;
    267 
    268                 psi=temp_psi;
    269             }
    270         }
    271     }
    272 
    273     if(!sw){
    274         SetError(52,name,cp);
    275         return 0;
    276     }
    277 
    278     return psi;
    279 }
    280 
    281 BOOL CParameter::ErrorCheck(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum){
    282     if(ParmsNum>pi_num){
    283         if(ppi[pi_num-1].type!=DEF_ELLIPSE){
    284             //パラメータが多すぎるとき
    285             SetError(10,FuncName,cp);
    286             return 0;
    287         }
    288     }
    289     else if(ParmsNum<pi_num){
    290         if(ParmsNum<SecondParmNum){
    291             if(ppi[ParmsNum].type==DEF_ELLIPSE){
    292                 return 1;
    293             }
    294 
    295             //パラメータが少なすぎるとき
    296             SetError(10,FuncName,cp);
    297             return 0;
    298         }
    299 
    300         //省略パラメータに "0" を指定する
    301         for(;ParmsNum < pi_num;ParmsNum++){
    302             extern HANDLE hHeap;
    303             char temporary[64];
    304             if(ppi[ParmsNum].bByVal) lstrcpy(temporary,"0");
    305             else sprintf(temporary,"%c%c0",1,ESC_BYVAL);
    306             Parms[ParmsNum]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
    307             lstrcpy(Parms[ParmsNum],temporary);
    308         }
    309     }
    310 
    311     return 1;
    312 }
    313 void CParameter::MacroParameterSupport(PARAMETER_INFO *ppi){
    314     int i;
    315     for(i=0;i<ParmsNum;i++){
    316         if(Parms[i][0]=='\0'){
    317             extern HANDLE hHeap;
    318             char temporary[64];
    319             if(ppi[i].bByVal) lstrcpy(temporary,"0");
    320             else sprintf(temporary,"%c%c0",1,ESC_BYVAL);
    321             HeapDefaultFree(Parms[i]);
    322             Parms[i]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
    323             lstrcpy(Parms[i],temporary);
    324         }
    325     }
    326 }
    3273
    3284void CParameter::NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum ){

  • BasicCompiler32/Compile_CallProc.cpp

    r47 r50  
    2929    pLocalVarAddrSchedule[LocalVarAddrScheduleNum]=obp;
    3030    LocalVarAddrScheduleNum++;
    31 }
    32 int CallProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex){
    33     int ret_type;
    34 
    35     if(idProc==PROC_DEFAULT){
    36         /////////////////////
    37         // ユーザー定義関数
    38         /////////////////////
    39 
    40         SUBINFO *psi;
    41         psi=(SUBINFO *)pInfo;
    42 
    43         //GetSubHash内でエラー提示が行われた場合
    44         if(psi==(SUBINFO *)-1) return -1;
    45 
    46 
    47         //オブジェクト名を取得
    48         char ObjectName[VN_SIZE];
    49         int RefType;
    50         SplitObjectName(name,ObjectName,&RefType);
    51 
    52 
    53         ////////////////////////
    54         // オーバーロードを解決
    55         ////////////////////////
    56 
    57         SUBINFO **ppsi;
    58         int num;
    59         ppsi=GetOverloadSubHash(name,&num);
    60         if(num){
    61             //オーバーロードを解決
    62             psi=OverloadSolutionWithStrParam(name,ppsi,num,Parameter,ObjectName,NULL);
    63             HeapDefaultFree(ppsi);
    64 
    65             if(!psi) return 0;
    66         }
    67 
    68 
    69         Opcode_CallProc(Parameter,psi,0,ObjectName,RefType);
    70         if( plpRetIndex ){
    71             *plpRetIndex = psi->u.ReturnIndex;
    72         }
    73         return psi->ReturnType;
    74     }
    75     else if(idProc==PROC_DLL){
    76         /////////////////////////
    77         // DLL関数
    78         /////////////////////////
    79         DECLAREINFO *pdi;
    80         pdi=(DECLAREINFO *)pInfo;
    81 
    82         ret_type=Opcode_CallDllProc(Parameter,pdi,plpRetIndex);
    83     }
    84     else if(idProc==PROC_BUILTIN){
    85         /////////////////////////
    86         // 組み込み関数
    87         /////////////////////////
    88         int FuncId;
    89         FuncId=(int)(_int64)pInfo;
    90 
    91         TYPEINFO ReturnTypeInfo = { DEF_LONG, NULL };
    92         Opcode_CallFunc( Parameter, FuncId, ReturnTypeInfo );
    93         if( plpRetIndex ){
    94             *plpRetIndex = ReturnTypeInfo.u.lpIndex;
    95         }
    96         return ReturnTypeInfo.type;
    97     }
    98     else if(idProc==PROC_PTR){
    99         /////////////////
    100         // 関数ポインタ
    101         /////////////////
    102 
    103         LONG_PTR lpIndex;
    104         GetVarType(name,&lpIndex,0);
    105 
    106         extern PROCPTRINFO *pProcPtrInfo;
    107         ret_type=Opcode_CallProcPtr(name,Parameter,&pProcPtrInfo[lpIndex],plpRetIndex);
    108     }
    109 
    110     return ret_type;
    111 }
    112 
    113 BOOL CallPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo){
    114     //プロパティ用のメソッドを呼び出す
    115 
    116     //配列要素を取得
    117     char VarName[VN_SIZE],ArrayElements[VN_SIZE];
    118     GetArrayElement(variable,VarName,ArrayElements);
    119 
    120     //オブジェクト名を取得
    121     char ObjectName[VN_SIZE];
    122     int RefType;
    123     SplitObjectName(VarName,ObjectName,&RefType);
    124 
    125     //オーバーロード用の関数リストを作成
    126     SUBINFO **ppsi;
    127     int num;
    128     ppsi=GetOverloadSubHash(VarName,&num);
    129     if(num==0){
    130         return 0;
    131     }
    132 
    133     //パラメータを整備
    134     char *Parameter;
    135     Parameter=(char *)HeapAlloc(hHeap,0,lstrlen(ArrayElements)+lstrlen(RightSide)+32);
    136     lstrcpy(Parameter,ArrayElements);
    137     if(RightSide){
    138         if(Parameter[0]&&RightSide[0]) lstrcat(Parameter,",");
    139         lstrcat(Parameter,RightSide);
    140     }
    141 
    142     //オーバーロードを解決
    143     SUBINFO *psi;
    144     psi=OverloadSolutionWithStrParam(VarName,ppsi,num,Parameter,ObjectName,NULL);
    145     HeapDefaultFree(ppsi);
    146 
    147     if(psi){
    148         //呼び出し
    149         Opcode_CallProc(Parameter,psi,0,ObjectName,RefType);
    150 
    151         if(pRetTypeInfo){
    152             pRetTypeInfo->type = psi->ReturnType;
    153             pRetTypeInfo->u.lpIndex = psi->u.ReturnIndex;
    154         }
    155     }
    156 
    157     HeapDefaultFree(Parameter);
    158 
    159     return 1;
    16031}
    16132

  • BasicCompiler32/Compile_Func.cpp

    r46 r50  
    249249        //左辺の型にのっとり、オーバーロードを解決
    250250
    251         SUBINFO **ppsi;
    252         int num;
    253         ppsi=GetOverloadSubHash(name,&num);
    254         if(!num){
    255             HeapDefaultFree(ppsi);
    256 
     251        std::vector<SUBINFO *> subs;
     252        GetOverloadSubHash( name, subs );
     253        if( subs.size() == 0 ){
    257254            SetError(27,name,cp);
    258255            return;
    … …  
    261258        //オーバーロードを解決
    262259        extern PROCPTRINFO *pProcPtrInfo;
    263         psi=OverloadSolution(name,ppsi,num,pProcPtrInfo[ProcPtr_BaseIndex].pParmInfo,pProcPtrInfo[ProcPtr_BaseIndex].ParmNum,NULL);
    264         HeapDefaultFree(ppsi);
     260        psi=OverloadSolution(name,subs,pProcPtrInfo[ProcPtr_BaseIndex].pParmInfo,pProcPtrInfo[ProcPtr_BaseIndex].ParmNum,NULL);
    265261
    266262        if(!psi){

  • BasicCompiler32/Compile_Object.cpp

    r40 r50  
    22#include "opcode.h"
    33
    4 void CallConstructor(CClass *pobj_c,char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
     4void _call_constructor(CClass *pobj_c,char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
    55    ////////////////////////////
    66    // コンストラクタの呼び出し
    … …  
    3131    ////////////////////////
    3232
    33     SUBINFO **ppsi;
     33    std::vector<SUBINFO *> subs;
     34    pobj_c->EnumMethod( pobj_c->name, subs );
     35
    3436    SUBINFO *psi;
    35     int num;
    36     ppsi=GetOverloadObjectSubHash(pobj_c->name,pobj_c,&num);
    37     if(num){
     37    if( subs.size() > 0 ){
    3838        //オーバーロードを解決
    3939        psi=OverloadSolutionWithStrParam(pobj_c->name,
    40             ppsi,num,CreateParameter,"",NULL);
    41         HeapDefaultFree(ppsi);
     40            subs,CreateParameter,"",NULL);
    4241
    4342        if(!psi) return;
    … …  
    253252    if(ObjectSize[0]) bSomeObjects=1;
    254253    else bSomeObjects=0;
    255     CallConstructor(pobj_c,CreateParameter,TypeSize,bSomeObjects);
     254    _call_constructor(pobj_c,CreateParameter,TypeSize,bSomeObjects);
    256255
    257256    return DEF_PTR_OBJECT;

  • BasicCompiler32/Compile_ProcOp.cpp

    r42 r50  
    7272                    TypeInfo.type=GlobalVar[i].type;
    7373                    TypeInfo.u.lpIndex=GlobalVar[i].u.index;
    74                     CallConstractor(
     74                    CallConstructor(
    7575                        GlobalVar[i].name,
    7676                        GlobalVar[i].SubScripts,

  • BasicCompiler32/Compile_Statement.cpp

    r40 r50  
    10951095                    pobj_c=(CClass *)lpIndex;
    10961096
    1097                     SUBINFO **ppsi;
    1098                     int num;
    1099                     ppsi=pobj_c->GetOperatorSubInfo(CALC_EQUAL,num);
    1100                     if(num==0){
    1101                         HeapDefaultFree(ppsi);
    1102 
     1097                    std::vector<SUBINFO *> subs;
     1098                    pobj_c->EnumMethod( CALC_EQUAL, subs );
     1099                    if( subs.size() == 0 ){
    11031100                        return;
    11041101                    }
    … …  
    11161113                    //オーバーロードを解決
    11171114                    SUBINFO *psi;
    1118                     psi=OverloadSolution("==",ppsi,num,ppi,iParmNum,NULL);
    1119                     HeapDefaultFree(ppsi);
     1115                    psi=OverloadSolution("==",subs,ppi,iParmNum,NULL);
    11201116                    HeapDefaultFree(ppi);
    11211117

  • BasicCompiler32/Compile_Var.cpp

    r49 r50  
    13041304        //コンストラクタ呼び出し
    13051305        if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&& isRef == false ){
    1306             CallConstractor(VarName,SubScripts,TypeInfo,ConstractParameter);
     1306            CallConstructor(VarName,SubScripts,TypeInfo,ConstractParameter);
    13071307        }
    13081308    }

  • BasicCompiler32/Opcode.h

    r49 r50  
    204204
    205205public:
    206     CParameter(char *buffer);
    207     CParameter(PARAMETER_INFO *pParamInfo,int ParmNum);
     206    CParameter(const char *buffer);
     207    CParameter(const PARAMETER_INFO *pParamInfo, const int ParmNum);
    208208    ~CParameter();
    209209    void SetReturnType(TYPEINFO *pTypeInfo);
    … …  
    211211private:
    212212    BOOL _overload_check(PARAMETER_INFO *ppi,int pi_num,TYPEINFO *pReturnTypeInfo,int overload_level);
    213     SUBINFO *OverloadSolutionWithReturnType(const char *name,SUBINFO **ppsi,int num);
     213    SUBINFO *OverloadSolutionWithReturnType( const char *name, std::vector<SUBINFO *> &subs );
    214214public:
    215     SUBINFO *OverloadSolution(const char *name,SUBINFO **ppsi,int num);
     215    SUBINFO *OverloadSolution( const char *name, std::vector<SUBINFO *> &subs );
    216216
    217217    BOOL ErrorCheck(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum);
    … …  
    227227//Compile_CallProc.cpp
    228228void AddLocalVarAddrSchedule();
    229 int CallProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex);
    230 BOOL CallPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo);
    231229#define PROCFLAG_NEW    1
    232230int Opcode_CallProcPtr(char *variable,char *Parameter,PROCPTRINFO *pi,LONG_PTR *plpIndex);

  • BasicCompiler32/OperatorProc.cpp

    r38 r50  
    2626    pobj_c=(CClass *)index_stack[sp-2];
    2727
    28     SUBINFO **ppsi;
    29     int num;
    30     ppsi=pobj_c->GetOperatorSubInfo(idCalc,num);
    31     if(num==0){
    32         HeapDefaultFree(ppsi);
    33 
     28    std::vector<SUBINFO *> subs;
     29    pobj_c->EnumMethod( idCalc, subs );
     30    if( subs.size() == 0 ){
    3431        return 0;
    3532    }
    … …  
    4340    int i;
    4441    BOOL bReturnTypeIsObject=1;
    45     TYPEINFO ReturnType={DEF_OBJECT,ppsi[0]->u.ReturnIndex};
    46     for(i=0;i<num;i++){
    47         if(ppsi[i]->ReturnType!=DEF_OBJECT)
     42    TYPEINFO ReturnType={DEF_OBJECT,subs[0]->u.ReturnIndex};
     43    foreach( SUBINFO *psi, subs ){
     44        if(psi->ReturnType!=DEF_OBJECT)
    4845            bReturnTypeIsObject=0;
    4946    }
    … …  
    8380    else GetCalcName(idCalc,temporary);
    8481    SUBINFO *psi;
    85     psi=OverloadSolution(temporary,ppsi,num,ppi,iParmNum,pBaseTypeInfo);
    86     HeapDefaultFree(ppsi);
     82    psi=OverloadSolution(temporary,subs,ppi,iParmNum,pBaseTypeInfo);
    8783
    8884    if(!psi){
    … …  
    263259}
    264260void CallIndexerGetterProc(CClass *pobj_Class,char *ObjectName,char *Parameter,TYPEINFO &RetTypeInfo){
    265     SUBINFO **ppsi;
    266     int num;
    267     ppsi=pobj_Class->GetOperatorSubInfo(CALC_ARRAY_GET,num);
    268     if(num==0){
    269         HeapDefaultFree(ppsi);
    270 
     261    std::vector<SUBINFO *> subs;
     262    pobj_Class->EnumMethod( CALC_ARRAY_GET, subs );
     263    if( subs.size() == 0 ){
    271264        return;
    272265    }
    273266
    274     Opcode_CallProc(Parameter,ppsi[0],0,ObjectName,DEF_OBJECT);
    275     RetTypeInfo.type=ppsi[0]->ReturnType;
    276     RetTypeInfo.u.lpIndex = ppsi[0]->u.ReturnIndex;
    277 
    278     HeapDefaultFree(ppsi);
    279 }
     267    Opcode_CallProc(Parameter,subs[0],0,ObjectName,DEF_OBJECT);
     268    RetTypeInfo.type = subs[0]->ReturnType;
     269    RetTypeInfo.u.lpIndex = subs[0]->u.ReturnIndex;
     270}

  • BasicCompiler64/BasicCompiler.vcproj

    r44 r50  
    4848                Name="VCCLCompilerTool"
    4949                Optimization="0"
     50                AdditionalIncludeDirectories="..\cpplibs\boost"
    5051                PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;JPN;_AMD64_;_WIN64"
    5152                MinimalRebuild="true"
    … …  
    13781379                    >
    13791380                </File>
    1380                 <File
    1381                     RelativePath="..\BasicCompiler_Common\Subroutine.cpp"
    1382                     >
    1383                 </File>
    13841381                <Filter
    13851382                    Name="Intermediate"
    … …  
    15391536                    <File
    15401537                        RelativePath="..\BasicCompiler_Common\NativeCode.h"
     1538                        >
     1539                    </File>
     1540                </Filter>
     1541                <Filter
     1542                    Name="Procedure"
     1543                    >
     1544                    <File
     1545                        RelativePath="..\BasicCompiler_Common\Parameter.cpp"
     1546                        >
     1547                    </File>
     1548                    <File
     1549                        RelativePath="..\BasicCompiler_Common\Subroutine.cpp"
    15411550                        >
    15421551                    </File>

  • BasicCompiler64/CParameter.cpp

    r47 r50  
    11#include "../BasicCompiler_Common/common.h"
    22#include "opcode.h"
    3 
    4 CParameter::CParameter(char *buffer){
    5     ///////////////////////////
    6     // パラメータ文字列を整理
    7     ///////////////////////////
    8 
    9     extern HANDLE hHeap;
    10     int i,i2,i3;
    11     char temporary[VN_SIZE];
    12 
    13     i=0;
    14     ParmsNum=0;
    15     while(1){
    16         if(buffer[i]=='\0') break;
    17 
    18         for(i2=0;;i2++,i++){
    19             if(buffer[i]=='\"'){
    20                 temporary[i2]=buffer[i];
    21                 for(i++,i2++;;i++,i2++){
    22                     temporary[i2]=buffer[i];
    23                     if(buffer[i]=='\"') break;
    24                 }
    25                 continue;
    26             }
    27 
    28             if(buffer[i]=='('){
    29                 i3=GetStringInPare(temporary+i2,buffer+i);
    30                 i2+=i3-1;
    31                 i+=i3-1;
    32                 continue;
    33             }
    34             if(buffer[i]=='['){
    35                 i3=GetStringInBracket(temporary+i2,buffer+i);
    36                 i2+=i3-1;
    37                 i+=i3-1;
    38                 continue;
    39             }
    40 
    41             if(buffer[i]==','||buffer[i]=='\0'){
    42                 temporary[i2]=0;
    43                 break;
    44             }
    45             temporary[i2]=buffer[i];
    46         }
    47 
    48         Parms[ParmsNum]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
    49         lstrcpy(Parms[ParmsNum],temporary);
    50         ParmsNum++;
    51 
    52         if(buffer[i]==',') i++;
    53     }
    54 
    55     ReturnTypeInfo.type=0;
    56     ReturnTypeInfo.u.lpIndex=0;
    57 }
    58 CParameter::CParameter(PARAMETER_INFO *pParamInfo,int ParmNum){
    59     int i;
    60     for(i=0;i<ParmNum;i++){
    61         Parms[i]=0;
    62         types[i].type=pParamInfo[i].type;
    63         types[i].u.lpIndex=pParamInfo[i].u.index;
    64     }
    65     this->ParmsNum=ParmNum;
    66 
    67     ReturnTypeInfo.type=0;
    68     ReturnTypeInfo.u.lpIndex=0;
    69 }
    70 CParameter::~CParameter(){
    71     int i2;
    72 
    73     //パラメータ文字列を解放
    74     for(i2=0;i2<ParmsNum;i2++){
    75         if(Parms[i2]==(char *)-1) continue;
    76 
    77         if(Parms[i2]) HeapDefaultFree(Parms[i2]);
    78     }
    79 }
    80 
    81 void CParameter::SetReturnType(TYPEINFO *pTypeInfo){
    82     ReturnTypeInfo=*pTypeInfo;
    83 }
    84 
    85 BOOL CParameter::_overload_check(PARAMETER_INFO *ppi,int pi_num,TYPEINFO *pReturnTypeInfo,int overload_level){
    86     //パラメータを識別してオーバーロードを解決
    87 
    88     //パラメータの個数が不一致の場合
    89     if(pi_num!=ParmsNum) return 0;
    90 
    91     int i,type;
    92     LONG_PTR lpIndex;
    93     for(i=0;i<pi_num;i++){
    94         if(Parms[i]){
    95             TYPEINFO BaseType={ppi[i].type,ppi[i].u.index};
    96             type=NumOpe_GetType(Parms[i],&BaseType,&lpIndex);
    97         }
    98         else{
    99             type=types[i].type;
    100             lpIndex=types[i].u.lpIndex;
    101         }
    102 
    103         if(type!=ppi[i].type){
    104             if(overload_level==OVERLOAD_LEVEL1){
    105                 return 0;
    106             }
    107             else if(overload_level==OVERLOAD_LEVEL2){
    108                 if(!(
    109                     IsWholeNumberType(type)&&IsWholeNumberType(ppi[i].type)||
    110                     IsRealNumberType(type)&&IsRealNumberType(ppi[i].type)
    111                     )) return 0;
    112             }
    113             else if(overload_level==OVERLOAD_LEVEL3){
    114                 if(type==DEF_OBJECT||ppi[i].type==DEF_OBJECT) return 0;
    115             }
    116         }
    117         else{
    118             if(NATURAL_TYPE(type)==DEF_OBJECT){
    119                 if(lpIndex!=ppi[i].u.index) return 0;
    120             }
    121         }
    122     }
    123 
    124     if(pReturnTypeInfo){
    125         //戻り値も比較対象にする
    126         if(ReturnTypeInfo.type==pReturnTypeInfo->type){
    127             if(NATURAL_TYPE(ReturnTypeInfo.type)==DEF_OBJECT){
    128                 if(ReturnTypeInfo.u.lpIndex != pReturnTypeInfo->u.lpIndex) return 0;
    129             }
    130         }
    131         else return 0;
    132     }
    133 
    134     return 1;
    135 }
    136 SUBINFO *CParameter::OverloadSolutionWithReturnType(const char *name,SUBINFO **ppsi,int num){
    137     int i,sw=0;
    138     SUBINFO *psi;
    139     psi=0;
    140     for(i=0;i<num;i++){
    141         psi=ppsi[i];
    142 
    143         TYPEINFO ReturnTypeInfo;
    144         ReturnTypeInfo.type=psi->ReturnType;
    145         ReturnTypeInfo.u.lpIndex=psi->u.ReturnIndex;
    146 
    147         //エラーチェック
    148         if(_overload_check(psi->pParmInfo,psi->ParmNum,&ReturnTypeInfo,OVERLOAD_LEVEL1)){
    149             if(sw){
    150                 SetError(52,name,cp);
    151                 return 0;
    152             }
    153             sw=1;
    154             break;
    155         }
    156     }
    157 
    158     if(!sw){
    159         for(i=0;i<num;i++){
    160             psi=ppsi[i];
    161 
    162             TYPEINFO ReturnTypeInfo;
    163             ReturnTypeInfo.type=psi->ReturnType;
    164             ReturnTypeInfo.u.lpIndex=psi->u.ReturnIndex;
    165 
    166             //エラーチェック
    167             if(_overload_check(psi->pParmInfo,psi->ParmNum,&ReturnTypeInfo,OVERLOAD_LEVEL2)){
    168                 if(sw){
    169                     SetError(52,name,cp);
    170                     return 0;
    171                 }
    172                 sw=1;
    173                 break;
    174             }
    175         }
    176     }
    177 
    178     if(!sw){
    179         for(i=0;i<num;i++){
    180             psi=ppsi[i];
    181 
    182             TYPEINFO ReturnTypeInfo;
    183             ReturnTypeInfo.type=psi->ReturnType;
    184             ReturnTypeInfo.u.lpIndex=psi->u.ReturnIndex;
    185 
    186             //エラーチェック
    187             if(_overload_check(psi->pParmInfo,psi->ParmNum,&ReturnTypeInfo,OVERLOAD_LEVEL3)){
    188                 if(sw){
    189                     SetError(52,name,cp);
    190                     return 0;
    191                 }
    192                 sw=1;
    193                 break;
    194             }
    195         }
    196     }
    197 
    198     if(!sw){
    199         SetError(52,name,cp);
    200         return 0;
    201     }
    202 
    203     return psi;
    204 }
    205 
    206 SUBINFO *CParameter::OverloadSolution(const char *name,SUBINFO **ppsi,int num){
    207     int i,sw=0;
    208     SUBINFO *psi;
    209     psi=0;
    210     for(i=0;i<num;i++){
    211         psi=ppsi[i];
    212 
    213         //エラーチェック
    214         if(_overload_check(psi->pParmInfo,psi->ParmNum,NULL,OVERLOAD_LEVEL1)){
    215             if(sw){
    216                 return OverloadSolutionWithReturnType(name,ppsi,num);
    217             }
    218             sw=1;
    219             break;
    220         }
    221     }
    222 
    223     if(!sw){
    224         for(i=0;i<num;i++){
    225             psi=ppsi[i];
    226 
    227             //エラーチェック
    228             if(_overload_check(psi->pParmInfo,psi->ParmNum,NULL,OVERLOAD_LEVEL2)){
    229                 if(sw){
    230                     return OverloadSolutionWithReturnType(name,ppsi,num);
    231                 }
    232                 sw=1;
    233                 break;
    234             }
    235         }
    236     }
    237 
    238     if(!sw){
    239         for(i=0;i<num;i++){
    240             psi=ppsi[i];
    241 
    242             //エラーチェック
    243             if(_overload_check(psi->pParmInfo,psi->ParmNum,NULL,OVERLOAD_LEVEL3)){
    244                 if(sw){
    245                     return OverloadSolutionWithReturnType(name,ppsi,num);
    246                 }
    247                 sw=1;
    248                 break;
    249             }
    250         }
    251     }
    252 
    253     if(!sw){
    254         SUBINFO *temp_psi;
    255         for(i=0;i<num;i++){
    256             temp_psi=ppsi[i];
    257 
    258             //エラーチェック
    259             if(temp_psi->ParmNum==this->ParmsNum){
    260                 if(sw){
    261                     sw=0;
    262                     break;
    263                 }
    264                 sw=1;
    265 
    266                 psi=temp_psi;
    267             }
    268         }
    269     }
    270 
    271     if(!sw){
    272         SetError(52,name,cp);
    273         return 0;
    274     }
    275 
    276     return psi;
    277 }
    278 
    279 BOOL CParameter::ErrorCheck(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum){
    280     if(ParmsNum>pi_num){
    281         if(ppi[pi_num-1].type!=DEF_ELLIPSE){
    282             //パラメータが多すぎるとき
    283             SetError(10,FuncName,cp);
    284             return 0;
    285         }
    286     }
    287     else if(ParmsNum<pi_num){
    288         if(ParmsNum<SecondParmNum){
    289             if(ppi[ParmsNum].type==DEF_ELLIPSE){
    290                 return 1;
    291             }
    292 
    293             //パラメータが少なすぎるとき
    294             SetError(10,FuncName,cp);
    295             return 0;
    296         }
    297 
    298         //省略パラメータに "0" を指定する
    299         for(;ParmsNum < pi_num;ParmsNum++){
    300             extern HANDLE hHeap;
    301             char temporary[64];
    302             if(ppi[ParmsNum].bByVal) lstrcpy(temporary,"0");
    303             else sprintf(temporary,"%c%c0",1,ESC_BYVAL);
    304             Parms[ParmsNum]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
    305             lstrcpy(Parms[ParmsNum],temporary);
    306         }
    307     }
    308 
    309     return 1;
    310 }
    311 void CParameter::MacroParameterSupport(PARAMETER_INFO *ppi){
    312     int i;
    313     for(i=0;i<ParmsNum;i++){
    314         if(Parms[i][0]=='\0'){
    315             extern HANDLE hHeap;
    316             char temporary[64];
    317             if(ppi[i].bByVal) lstrcpy(temporary,"0");
    318             else sprintf(temporary,"%c%c0",1,ESC_BYVAL);
    319             HeapDefaultFree(Parms[i]);
    320             Parms[i]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
    321             lstrcpy(Parms[i],temporary);
    322         }
    323     }
    324 }
    3253
    3264void CParameter::NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum ){

  • BasicCompiler64/Compile_CallProc.cpp

    r47 r50  
    2929    pLocalVarAddrSchedule[LocalVarAddrScheduleNum]=obp;
    3030    LocalVarAddrScheduleNum++;
    31 }
    32 
    33 int CallProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex){
    34     int ret_type;
    35 
    36     if(idProc==PROC_DEFAULT){
    37         /////////////////////
    38         // ユーザー定義関数
    39         /////////////////////
    40 
    41         SUBINFO *psi;
    42         psi=(SUBINFO *)pInfo;
    43 
    44         //GetSubHash内でエラー提示が行われた場合
    45         if(psi==(SUBINFO *)-1) return -1;
    46 
    47 
    48         //オブジェクト名を取得
    49         char ObjectName[VN_SIZE];
    50         int RefType;
    51         SplitObjectName(name,ObjectName,&RefType);
    52 
    53 
    54         ////////////////////////
    55         // オーバーロードを解決
    56         ////////////////////////
    57 
    58         SUBINFO **ppsi;
    59         int num;
    60         ppsi=GetOverloadSubHash(name,&num);
    61         if(num){
    62             //オーバーロードを解決
    63             psi=OverloadSolutionWithStrParam(name,ppsi,num,Parameter,ObjectName,NULL);
    64             HeapDefaultFree(ppsi);
    65 
    66             if(!psi) return 0;
    67         }
    68 
    69 
    70         Opcode_CallProc(Parameter,psi,0,ObjectName,RefType);
    71         if( plpRetIndex ){
    72             *plpRetIndex = psi->u.ReturnIndex;
    73         }
    74         return psi->ReturnType;
    75     }
    76     else if(idProc==PROC_DLL){
    77         /////////////////////////
    78         // DLL関数
    79         /////////////////////////
    80         DECLAREINFO *pdi;
    81         pdi=(DECLAREINFO *)pInfo;
    82 
    83         ret_type=Opcode_CallDllProc(Parameter,pdi,plpRetIndex);
    84     }
    85     else if(idProc==PROC_BUILTIN){
    86         /////////////////////////
    87         // 組み込み関数
    88         /////////////////////////
    89         int FuncId;
    90         FuncId=(int)(_int64)pInfo;
    91 
    92         TYPEINFO ReturnTypeInfo = { DEF_LONG, NULL };
    93         Opcode_CallFunc( Parameter, FuncId, ReturnTypeInfo );
    94         if( plpRetIndex ){
    95             *plpRetIndex = ReturnTypeInfo.u.lpIndex;
    96         }
    97         return ReturnTypeInfo.type;
    98     }
    99     else if(idProc==PROC_PTR){
    100         /////////////////
    101         // 関数ポインタ
    102         /////////////////
    103 
    104         LONG_PTR lpIndex;
    105         GetVarType(name,&lpIndex,0);
    106 
    107         extern PROCPTRINFO *pProcPtrInfo;
    108         ret_type=Opcode_CallProcPtr(name,Parameter,&pProcPtrInfo[lpIndex],plpRetIndex);
    109     }
    110 
    111     return ret_type;
    112 }
    113 
    114 BOOL CallPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo){
    115     //プロパティ用のメソッドを呼び出す
    116 
    117     //配列要素を取得
    118     char VarName[VN_SIZE],ArrayElements[VN_SIZE];
    119     GetArrayElement(variable,VarName,ArrayElements);
    120 
    121     //オブジェクト名を取得
    122     char ObjectName[VN_SIZE];
    123     int RefType;
    124     SplitObjectName(VarName,ObjectName,&RefType);
    125 
    126     //オーバーロード用の関数リストを作成
    127     SUBINFO **ppsi;
    128     int num;
    129     ppsi=GetOverloadSubHash(VarName,&num);
    130     if(num==0){
    131         return 0;
    132     }
    133 
    134     //パラメータを整備
    135     char *Parameter;
    136     Parameter=(char *)HeapAlloc(hHeap,0,lstrlen(ArrayElements)+lstrlen(RightSide)+32);
    137     lstrcpy(Parameter,ArrayElements);
    138     if(RightSide){
    139         if(Parameter[0]&&RightSide[0]) lstrcat(Parameter,",");
    140         lstrcat(Parameter,RightSide);
    141     }
    142 
    143     //オーバーロードを解決
    144     SUBINFO *psi;
    145     psi=OverloadSolutionWithStrParam(VarName,ppsi,num,Parameter,ObjectName,NULL);
    146     HeapDefaultFree(ppsi);
    147 
    148     if(psi){
    149         //呼び出し
    150         Opcode_CallProc(Parameter,psi,0,ObjectName,RefType);
    151 
    152         if( pRetTypeInfo ){
    153             pRetTypeInfo->type = psi->ReturnType;
    154             pRetTypeInfo->u.lpIndex = psi->u.ReturnIndex;
    155         }
    156     }
    157 
    158     HeapDefaultFree(Parameter);
    159 
    160     return 1;
    16131}
    16232

  • BasicCompiler64/Compile_Func.cpp

    r46 r50  
    101101        //左辺の型にのっとり、オーバーロードを解決
    102102
    103         SUBINFO **ppsi;
    104         int num;
    105         ppsi=GetOverloadSubHash( name, &num );
    106         if(!num){
    107             HeapDefaultFree(ppsi);
    108 
     103        std::vector<SUBINFO *> subs;
     104        GetOverloadSubHash( name, subs );
     105        if( subs.size() == 0 ){
    109106            SetError(27,name,cp);
    110107            return;
    … …  
    113110        //オーバーロードを解決
    114111        extern PROCPTRINFO *pProcPtrInfo;
    115         psi=OverloadSolution(name,ppsi,num,pProcPtrInfo[ProcPtr_BaseIndex].pParmInfo,pProcPtrInfo[ProcPtr_BaseIndex].ParmNum,NULL);
    116         HeapDefaultFree(ppsi);
     112        psi=OverloadSolution(name,subs,pProcPtrInfo[ProcPtr_BaseIndex].pParmInfo,pProcPtrInfo[ProcPtr_BaseIndex].ParmNum,NULL);
    117113
    118114        if(!psi){

  • BasicCompiler64/Compile_Object.cpp

    r31 r50  
    22#include "opcode.h"
    33
    4 void CallConstructor(CClass *pobj_c,char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
     4void _call_constructor(CClass *pobj_c,char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
    55    ////////////////////////////
    66    // コンストラクタの呼び出し
    … …  
    3232    ////////////////////////
    3333
    34     SUBINFO **ppsi;
     34    std::vector<SUBINFO *> subs;
     35    pobj_c->EnumMethod( pobj_c->name, subs );
     36
    3537    SUBINFO *psi;
    36     int num;
    37     ppsi=GetOverloadObjectSubHash(pobj_c->name,pobj_c,&num);
    38     if(num){
     38    if( subs.size() > 0 ){
    3939        //オーバーロードを解決
    4040        psi=OverloadSolutionWithStrParam(pobj_c->name,
    41             ppsi,num,CreateParameter,"",NULL);
    42         HeapDefaultFree(ppsi);
     41            subs,CreateParameter,"",NULL);
    4342
    4443        if(!psi) return;
    … …  
    227226    ////////////////////////////
    228227
    229     CallConstructor(pobj_c,CreateParameter,TypeSize,bSomeObjects);
     228    _call_constructor(pobj_c,CreateParameter,TypeSize,bSomeObjects);
    230229
    231230

  • BasicCompiler64/Compile_ProcOp.cpp

    r44 r50  
    8484                    TypeInfo.type=GlobalVar[i].type;
    8585                    TypeInfo.u.lpIndex=GlobalVar[i].u.index;
    86                     CallConstractor(
     86                    CallConstructor(
    8787                        GlobalVar[i].name,
    8888                        GlobalVar[i].SubScripts,

  • BasicCompiler64/Compile_Statement.cpp

    r48 r50  
    725725                    pobj_c=(CClass *)lpIndex;
    726726
    727                     SUBINFO **ppsi;
    728                     int num;
    729                     ppsi=pobj_c->GetOperatorSubInfo(CALC_EQUAL,num);
    730                     if(num==0){
    731                         HeapDefaultFree(ppsi);
    732 
     727                    std::vector<SUBINFO *> subs;
     728                    pobj_c->EnumMethod( CALC_EQUAL, subs );
     729                    if( subs.size() == 0 ){
    733730                        return;
    734731                    }
    … …  
    746743                    //オーバーロードを解決
    747744                    SUBINFO *psi;
    748                     psi=OverloadSolution("==",ppsi,num,ppi,iParmNum,NULL);
    749                     HeapDefaultFree(ppsi);
     745                    psi=OverloadSolution("==",subs,ppi,iParmNum,NULL);
    750746                    HeapDefaultFree(ppi);
    751747

  • BasicCompiler64/Compile_Var.cpp

    r49 r50  
    13001300        //コンストラクタ呼び出し
    13011301        if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&& isRef == false ){
    1302             CallConstractor(VarName,SubScripts,TypeInfo,ConstractParameter);
     1302            CallConstructor(VarName,SubScripts,TypeInfo,ConstractParameter);
    13031303        }
    13041304    }

  • BasicCompiler64/Opcode.h

    r49 r50  
    341341
    342342public:
    343     CParameter(char *buffer);
    344     CParameter(PARAMETER_INFO *pParamInfo,int ParmNum);
     343    CParameter(const char *buffer);
     344    CParameter(const PARAMETER_INFO *pParamInfo, const int ParmNum);
    345345    ~CParameter();
    346346    void SetReturnType(TYPEINFO *pTypeInfo);
    … …  
    348348private:
    349349    BOOL _overload_check(PARAMETER_INFO *ppi,int pi_num,TYPEINFO *pReturnTypeInfo,int overload_level);
    350     SUBINFO *OverloadSolutionWithReturnType(const char *name,SUBINFO **ppsi,int num);
     350    SUBINFO *OverloadSolutionWithReturnType( const char *name, std::vector<SUBINFO *> &subs );
    351351public:
    352     SUBINFO *OverloadSolution(const char *name,SUBINFO **ppsi,int num);
     352    SUBINFO *OverloadSolution( const char *name, std::vector<SUBINFO *> &subs );
    353353
    354354    BOOL ErrorCheck(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum);
    … …  
    380380//Compile_CallProc.cpp
    381381void AddLocalVarAddrSchedule();
    382 int CallProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex);
    383 BOOL CallPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo);
    384382#define PROCFLAG_NEW    1
    385383int Opcode_CallProcPtr(char *variable,char *Parameter,PROCPTRINFO *pi,LONG_PTR *plpIndex);

  • BasicCompiler64/OperatorProc.cpp

    r38 r50  
    3131    pobj_c=(CClass *)index_stack[sp-2];
    3232
    33     SUBINFO **ppsi;
    34     int num;
    35     ppsi=pobj_c->GetOperatorSubInfo(idCalc,num);
    36     if(num==0){
    37         HeapDefaultFree(ppsi);
    38 
     33    std::vector<SUBINFO *> subs;
     34    pobj_c->EnumMethod( idCalc, subs );
     35    if( subs.size() == 0 ){
    3936        return 0;
    4037    }
    … …  
    4845    int i;
    4946    BOOL bReturnTypeIsObject=1;
    50     TYPEINFO ReturnType={DEF_OBJECT,ppsi[0]->u.ReturnIndex};
    51     for(i=0;i<num;i++){
    52         if(ppsi[i]->ReturnType!=DEF_OBJECT)
     47    TYPEINFO ReturnType={DEF_OBJECT,subs[0]->u.ReturnIndex};
     48    for(i=0;i<subs.size();i++){
     49        if(subs[i]->ReturnType!=DEF_OBJECT)
    5350            bReturnTypeIsObject=0;
    5451    }
    … …  
    8885    else GetCalcName(idCalc,temporary);
    8986    SUBINFO *psi;
    90     psi=OverloadSolution(temporary,ppsi,num,ppi,iParmNum,pBaseTypeInfo);
    91     HeapDefaultFree(ppsi);
     87    psi=OverloadSolution(temporary,subs,ppi,iParmNum,pBaseTypeInfo);
     88
    9289
    9390    if(!psi){
    … …  
    438435//インデクサ（getter）を呼び出す
    439436void CallIndexerGetterProc(int reg,CClass *pobj_Class,char *ObjectName,char *Parameter,TYPEINFO &RetTypeInfo){
    440     SUBINFO **ppsi;
    441     int num;
    442     ppsi=pobj_Class->GetOperatorSubInfo(CALC_ARRAY_GET,num);
    443     if(num==0){
    444         HeapDefaultFree(ppsi);
    445 
     437
     438    std::vector<SUBINFO *> subs;
     439    pobj_Class->EnumMethod( CALC_ARRAY_GET, subs );
     440    if( subs.size() == 0 ){
    446441        return;
    447442    }
    … …  
    452447    //////////////////////////////////////////////////////
    453448
    454         Opcode_CallProc(Parameter,ppsi[0],0,ObjectName,DEF_OBJECT);
    455         RetTypeInfo.type = ppsi[0]->ReturnType;
    456         RetTypeInfo.u.lpIndex = ppsi[0]->u.ReturnIndex;
     449        Opcode_CallProc(Parameter,subs[0],0,ObjectName,DEF_OBJECT);
     450        RetTypeInfo.type = subs[0]->ReturnType;
     451        RetTypeInfo.u.lpIndex = subs[0]->u.ReturnIndex;
    457452
    458453        //mov reg,rax
    … …  
    464459    }////////////////////////////////////////////
    465460
    466     HeapDefaultFree(ppsi);
    467461}

  • BasicCompiler_Common/Class.cpp

    r46 r50  
    142142                cp=pobj_c->ppobj_StaticMember[i]->source_code_address;
    143143
    144                 CallConstractor(temporary,
     144                CallConstructor(temporary,
    145145                    pobj_c->ppobj_StaticMember[i]->SubScripts,
    146146                    pobj_c->ppobj_StaticMember[i]->TypeInfo,
    … …  
    225225    }
    226226
    227     if(ppobj_StaticMethod){
    228         //静的メソッド
    229         for(i=0;i<iStaticMethodNum;i++){
    230             delete ppobj_StaticMethod[i];
    231         }
    232         HeapDefaultFree(ppobj_StaticMethod);
    233         ppobj_StaticMethod=0;
     227    foreach( CMethod *method, StaticMethods ){
     228        delete method;
    234229    }
    235230}
    … …  
    306301}
    307302void CClass::AddStaticMethod(SUBINFO *psi,DWORD dwAccess){
    308     ppobj_StaticMethod=(CMethod **)HeapReAlloc(hHeap,0,ppobj_StaticMethod,(iStaticMethodNum+1)*sizeof(CMethod *));
    309     ppobj_StaticMethod[iStaticMethodNum]=new CMethod();
    310     ppobj_StaticMethod[iStaticMethodNum]->psi=psi;
    311     ppobj_StaticMethod[iStaticMethodNum]->dwAccess=dwAccess;
    312     ppobj_StaticMethod[iStaticMethodNum]->bAbstract=0;
    313     ppobj_StaticMethod[iStaticMethodNum]->bVirtual=0;
    314     ppobj_StaticMethod[iStaticMethodNum]->pobj_InheritsClass=0;
    315 
    316     iStaticMethodNum++;
     303    CMethod *method = new CMethod();
     304    method->psi=psi;
     305    method->dwAccess=dwAccess;
     306    method->bAbstract=0;
     307    method->bVirtual=0;
     308    method->pobj_InheritsClass=0;
     309
     310    StaticMethods.push_back( method );
    317311}
    318312BOOL CClass::DupliCheckAll(const char *name){
    … …  
    355349}
    356350CMethod *CClass::GetMethodInfo( SUBINFO *psi ){
    357     int i;
    358     for( i=0; i<iMethodNum; i++ ){
    359         if( psi == ppobj_Method[i]->psi ) break;
    360     }
    361     if( i == iMethodNum ){
    362         return NULL;
    363     }
    364     return ppobj_Method[i];
     351    for( int i=iMethodNum-1; i>=0; i-- ){
     352        if( psi == ppobj_Method[i]->psi ) return ppobj_Method[i];
     353    }
     354    return NULL;
    365355}
    366356CMethod *CClass::GetStaticMethodInfo( SUBINFO *psi ){
    367     int i;
    368     for( i=0; i<iStaticMethodNum; i++ ){
    369         if( psi == ppobj_StaticMethod[i]->psi ) break;
    370     }
    371     if( i == iStaticMethodNum ){
    372         return NULL;
    373     }
    374     return ppobj_StaticMethod[i];
     357    for( int i=(int)StaticMethods.size()-1; i>=0; i-- ){
     358        if( psi == StaticMethods[i]->psi ) return StaticMethods[i];
     359    }
     360    return NULL;
    375361}
    376362bool CClass::IsExistMethod( const char *name ){
    … …  
    381367}
    382368bool CClass::IsExistStaticMethod( const char *name ){
    383     for( int i=0; i<iStaticMethodNum; i++ ){
    384         if( lstrcmp( ppobj_StaticMethod[i]->psi->name, name ) == 0 ) return true;
     369    foreach( CMethod *method, StaticMethods ){
     370        if( lstrcmp( method->psi->name, name ) == 0 ) return true;
    385371    }
    386372    return false;
     373}
     374
     375void CClass::EnumStaticMethod( const char *methodName, std::vector<SUBINFO *> &subs ) const
     376{
     377    foreach( CMethod *method, StaticMethods ){
     378        if(lstrcmp(methodName,method->psi->name)==0){
     379            subs.push_back( method->psi );
     380        }
     381    }
     382}
     383
     384void CClass::EnumMethod( const char *methodName, std::vector<SUBINFO *> &subs ) const
     385{
     386    //オブジェクトのメンバ関数の場合
     387    //※オーバーライドされた関数を先にサーチする必要があるため、バックサーチを行う
     388    for(int i=iMethodNum-1;i>=0;i--){
     389        if(lstrcmp(name,ppobj_Method[i]->psi->name)==0){
     390            subs.push_back( ppobj_Method[i]->psi );
     391        }
     392    }
     393}
     394
     395void CClass::EnumMethod( const BYTE idOperatorCalc, std::vector<SUBINFO *> &subs ) const
     396{
     397    for(int i=0;i<iMethodNum;i++){
     398        char *temp;
     399        temp=ppobj_Method[i]->psi->name;
     400        if(temp[0]==1&&temp[1]==ESC_OPERATOR){
     401            if((BYTE)temp[2]==idOperatorCalc){
     402                subs.push_back( ppobj_Method[i]->psi );
     403            }
     404        }
     405    }
    387406}
    388407
    … …  
    465484
    466485    return false;
    467 }
    468 
    469 
    470 SUBINFO **CClass::GetOperatorSubInfo(BYTE idCalc,int &num){
    471     //格納のための構造体配列を用意
    472     SUBINFO **ppArray_si;
    473     ppArray_si=(SUBINFO **)HeapAlloc(hHeap,0,sizeof(SUBINFO *)*1024);
    474     num=0;
    475 
    476     int i;
    477     for(i=0;i<iMethodNum;i++){
    478         char *temp;
    479         temp=ppobj_Method[i]->psi->name;
    480         if(temp[0]==1&&temp[1]==ESC_OPERATOR){
    481             if((BYTE)temp[2]==idCalc){
    482                 ppArray_si[num]=ppobj_Method[i]->psi;
    483                 num++;
    484             }
    485         }
    486     }
    487 
    488     return ppArray_si;
    489486}
    490487
    … …  
    895892            pobj_c->ppobj_Method=(CMethod **)HeapAlloc(hHeap,0,1);
    896893            pobj_c->iMethodNum=0;
    897             pobj_c->ppobj_StaticMethod=(CMethod **)HeapAlloc(hHeap,0,1);
    898             pobj_c->iStaticMethodNum=0;
    899894
    900895            pobj_c->ConstructorMemberSubIndex=-1;
    … …  
    10571052            pobj_c->ppobj_Method=(CMethod **)HeapAlloc(hHeap,0,1);
    10581053            pobj_c->iMethodNum=0;
    1059             pobj_c->ppobj_StaticMethod=(CMethod **)HeapAlloc(hHeap,0,1);
    1060             pobj_c->iStaticMethodNum=0;
    10611054
    10621055            pobj_c->ConstructorMemberSubIndex=-1;

  • BasicCompiler_Common/Class.h

    r46 r50  
    1 
     1#include <vector>
    22
    33class CClass;
    … …  
    6161};
    6262class CClass{
     63    //静的メソッド情報
     64    std::vector<CMethod *> StaticMethods;
     65
    6366public:
    6467    //クラス名
    … …  
    8386    int iStaticMemberNum;
    8487
    85     //静的メソッド情報
    86     CMethod **ppobj_StaticMethod;
    87     int iStaticMethodNum;
    88 
    8988    //仮想関数の数
    9089    int vtbl_num;
    … …  
    117116    bool IsExistStaticMethod( const char *name );
    118117
     118    //メソッドを列挙
     119    void EnumStaticMethod( const char *methodName, std::vector<SUBINFO *> &subs ) const;
     120    void EnumMethod( const char *methodName, std::vector<SUBINFO *> &subs ) const;
     121    void EnumMethod( const BYTE idOperatorCalc, std::vector<SUBINFO *> &subs ) const;
     122
    119123
    120124    //vtbl
    … …  
    126130    void ActionVtblSchedule(LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection);
    127131    bool IsAbstract();
    128 
    129 
    130     //オペレータ関数の取得
    131     SUBINFO **GetOperatorSubInfo(BYTE idCalc,int &num);
    132132
    133133

  • BasicCompiler_Common/NumOpe_GetType.cpp

    r49 r50  
    193193    pobj_c=(CClass *)index_stack[sp-2];
    194194
    195     SUBINFO **ppsi;
    196     int num;
    197     ppsi=pobj_c->GetOperatorSubInfo(idCalc,num);
    198     if(num==0){
    199         HeapDefaultFree(ppsi);
    200 
     195    std::vector<SUBINFO *> subs;
     196    pobj_c->EnumMethod( idCalc, subs );
     197    if( subs.size() == 0 ){
    201198        return 0;
    202199    }
    … …  
    234231    else GetCalcName(idCalc,temporary);
    235232    SUBINFO *psi;
    236     psi=OverloadSolution(temporary,ppsi,num,ppi,iParmNum,pBaseTypeInfo);
    237     HeapDefaultFree(ppsi);
     233    psi=OverloadSolution(temporary,subs,ppi,iParmNum,pBaseTypeInfo);
     234
    238235
    239236    if(!psi){

  • BasicCompiler_Common/Object.cpp

    r40 r50  
    113113
    114114
    115 void CallConstractor(char *ObjectName,int *SubScripts,TYPEINFO &TypeInfo,char *Parameter){
     115void CallConstructor(char *ObjectName,int *SubScripts,TYPEINFO &TypeInfo,char *Parameter){
    116116    if(TypeInfo.type!=DEF_OBJECT) return;
    117117

  • BasicCompiler_Common/Overload.cpp

    r46 r50  
    77#endif
    88
    9 SUBINFO *OverloadSolutionWithStrParam(char *name,SUBINFO **ppsi,int num,char *Parameter,char *ObjectName,TYPEINFO *pReturnTypeInfo){
    10     // オーバーロードの解決
     9SUBINFO *OverloadSolutionWithStrParam(
     10    const char *name,
     11    std::vector<SUBINFO *> &subs,
     12    const char *Parameter,
     13    const char *ObjectName,
     14    TYPEINFO *pReturnTypeInfo){
    1115
    12     //オーバーロードされていないとき
    13     if(num==1) return ppsi[0];
     16        // オーバーロードの解決
     17
     18        //オーバーロードされていないとき
     19        if( subs.size() == 1 ) return subs[0];
    1420
    1521
    16     ////////////////////////
    17     // パラメータをセット
    18     ////////////////////////
     22        ////////////////////////
     23        // パラメータをセット
     24        ////////////////////////
    1925
    20     CParameter *pobj_parameter=0;
     26        CParameter *pobj_parameter=0;
    2127
    22     char MethodName[VN_SIZE];
    23     if( !SplitMemberName( name, NULL, MethodName ) ) lstrcpy( MethodName, name );
     28        char MethodName[VN_SIZE];
     29        if( !SplitMemberName( name, NULL, MethodName ) ) lstrcpy( MethodName, name );
    2430
    25     //メソッドの場合は静的かどうかを調べる
    26     bool isStatic = false;
    27     CClass *pClass = ppsi[0]->pobj_ParentClass;
    28     if( pClass ){
    29         isStatic = pClass->IsExistStaticMethod( MethodName );
    30     }
     31        //メソッドの場合は静的かどうかを調べる
     32        bool isStatic = false;
     33        CClass *pClass = subs[0]->pobj_ParentClass;
     34        if( pClass ){
     35            isStatic = pClass->IsExistStaticMethod( MethodName );
     36        }
    3137
    32     //パラメータオブジェクトを生成
    33     pobj_parameter=new CParameter(Parameter);
    34     if(pReturnTypeInfo) pobj_parameter->SetReturnType(pReturnTypeInfo);
     38        //パラメータオブジェクトを生成
     39        pobj_parameter=new CParameter(Parameter);
     40        if(pReturnTypeInfo) pobj_parameter->SetReturnType(pReturnTypeInfo);
    3541
    3642
    37     SUBINFO *psi;
    38     psi=pobj_parameter->OverloadSolution(name,ppsi,num);
     43        SUBINFO *psi;
     44        psi=pobj_parameter->OverloadSolution(name,subs);
    3945
    4046
    41     //パラメータオブジェクトを破棄
    42     delete pobj_parameter;
    43     pobj_parameter=0;
     47        //パラメータオブジェクトを破棄
     48        delete pobj_parameter;
     49        pobj_parameter=0;
    4450
    45     return psi;
     51        return psi;
    4652}
    4753
    48 SUBINFO *OverloadSolution(const char *name,SUBINFO **ppsi,int num,PARAMETER_INFO *ppi,int ParmNum,TYPEINFO *pReturnTypeInfo){
    49     // オーバーロードの解決
     54SUBINFO *OverloadSolution(
     55    const char *name,
     56    std::vector<SUBINFO *> &subs,
     57    const PARAMETER_INFO *ppi,
     58    const int ParmNum,
     59    TYPEINFO *pReturnTypeInfo){
    5060
    51     //オーバーロードされていないとき
    52     if(num==1) return ppsi[0];
     61        // オーバーロードの解決
     62
     63        //オーバーロードされていないとき
     64        if( subs.size() == 1 ) return subs[0];
    5365
    5466
    55     CParameter *pobj_Parameter=new CParameter(ppi,ParmNum);
    56     if(pReturnTypeInfo) pobj_Parameter->SetReturnType(pReturnTypeInfo);
     67        CParameter *pobj_Parameter=new CParameter(ppi,ParmNum);
     68        if(pReturnTypeInfo) pobj_Parameter->SetReturnType(pReturnTypeInfo);
    5769
    58     SUBINFO *psi;
    59     psi=pobj_Parameter->OverloadSolution(name,ppsi,num);
     70        SUBINFO *psi;
     71        psi=pobj_Parameter->OverloadSolution(name,subs);
    6072
    61     delete pobj_Parameter;
     73        delete pobj_Parameter;
    6274
    63     return psi;
     75        return psi;
    6476}

  • BasicCompiler_Common/Subroutine.cpp

    r46 r50  
    104104    return true;
    105105}
    106 int GetReturnTypeOfProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex){
     106
     107
     108int CallProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex){
    107109    int ret_type;
    108110
    … …  
    129131        ////////////////////////
    130132
    131         SUBINFO **ppsi;
    132         int num;
    133         ppsi=GetOverloadSubHash(name,&num);
    134         if(num){
     133        std::vector<SUBINFO *> subs;
     134        GetOverloadSubHash(name,subs);
     135        if(subs.size()){
    135136            //オーバーロードを解決
    136             psi=OverloadSolutionWithStrParam(name,ppsi,num,Parameter,ObjectName,NULL);
    137             HeapDefaultFree(ppsi);
     137            psi=OverloadSolutionWithStrParam(name,subs,Parameter,ObjectName,NULL);
    138138
    139139            if(!psi) return 0;
    … …  
    141141
    142142
    143         ret_type=psi->ReturnType;
    144         *plpRetIndex=psi->u.ReturnIndex;
     143        Opcode_CallProc(Parameter,psi,0,ObjectName,RefType);
     144        if( plpRetIndex ){
     145            *plpRetIndex = psi->u.ReturnIndex;
     146        }
     147        return psi->ReturnType;
    145148    }
    146149    else if(idProc==PROC_DLL){
    … …  
    151154        pdi=(DECLAREINFO *)pInfo;
    152155
    153         ret_type=pdi->ReturnType;
    154         *plpRetIndex=pdi->u.ReturnIndex;
     156        ret_type=Opcode_CallDllProc(Parameter,pdi,plpRetIndex);
    155157    }
    156158    else if(idProc==PROC_BUILTIN){
    … …  
    161163        FuncId=(int)(_int64)pInfo;
    162164
    163         ret_type=GetFunctionType(FuncId);
    164         *plpRetIndex=-1;
     165        TYPEINFO ReturnTypeInfo = { DEF_LONG, NULL };
     166        Opcode_CallFunc( Parameter, FuncId, ReturnTypeInfo );
     167        if( plpRetIndex ){
     168            *plpRetIndex = ReturnTypeInfo.u.lpIndex;
     169        }
     170        return ReturnTypeInfo.type;
    165171    }
    166172    else if(idProc==PROC_PTR){
    … …  
    173179
    174180        extern PROCPTRINFO *pProcPtrInfo;
    175         ret_type=pProcPtrInfo[lpIndex].ReturnType;
    176         *plpRetIndex=pProcPtrInfo[lpIndex].u.ReturnIndex;
     181        ret_type=Opcode_CallProcPtr(name,Parameter,&pProcPtrInfo[lpIndex],plpRetIndex);
    177182    }
    178183
    179184    return ret_type;
    180185}
    181 BOOL GetReturnTypeOfPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo){
     186BOOL CallPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo){
    182187    //プロパティ用のメソッドを呼び出す
    183188
    … …  
    192197
    193198    //オーバーロード用の関数リストを作成
    194     SUBINFO **ppsi;
    195     int num;
    196     ppsi=GetOverloadSubHash(VarName,&num);
    197     if(num==0){
     199    std::vector<SUBINFO *> subs;
     200    GetOverloadSubHash(VarName,subs);
     201    if(subs.size()==0){
    198202        return 0;
    199203    }
    … …  
    210214    //オーバーロードを解決
    211215    SUBINFO *psi;
    212     psi=OverloadSolutionWithStrParam(VarName,ppsi,num,Parameter,ObjectName,NULL);
    213     HeapDefaultFree(ppsi);
     216    psi=OverloadSolutionWithStrParam(VarName,subs,Parameter,ObjectName,NULL);
     217
     218    if(psi){
     219        //呼び出し
     220        Opcode_CallProc(Parameter,psi,0,ObjectName,RefType);
     221
     222        if( pRetTypeInfo ){
     223            pRetTypeInfo->type = psi->ReturnType;
     224            pRetTypeInfo->u.lpIndex = psi->u.ReturnIndex;
     225        }
     226    }
     227
     228    HeapDefaultFree(Parameter);
     229
     230    return 1;
     231}
     232
     233
     234int GetReturnTypeOfProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex){
     235    int ret_type;
     236
     237    if(idProc==PROC_DEFAULT){
     238        /////////////////////
     239        // ユーザー定義関数
     240        /////////////////////
     241
     242        SUBINFO *psi;
     243        psi=(SUBINFO *)pInfo;
     244
     245        //GetSubHash内でエラー提示が行われた場合
     246        if(psi==(SUBINFO *)-1) return -1;
     247
     248
     249        //オブジェクト名を取得
     250        char ObjectName[VN_SIZE];
     251        int RefType;
     252        SplitObjectName(name,ObjectName,&RefType);
     253
     254
     255        ////////////////////////
     256        // オーバーロードを解決
     257        ////////////////////////
     258
     259        std::vector<SUBINFO *> subs;
     260        GetOverloadSubHash(name,subs);
     261        if( subs.size() > 0 ){
     262            //オーバーロードを解決
     263            psi=OverloadSolutionWithStrParam(name,subs,Parameter,ObjectName,NULL);
     264
     265            if(!psi) return 0;
     266        }
     267
     268
     269        ret_type=psi->ReturnType;
     270        *plpRetIndex=psi->u.ReturnIndex;
     271    }
     272    else if(idProc==PROC_DLL){
     273        /////////////////////////
     274        // DLL関数
     275        /////////////////////////
     276        DECLAREINFO *pdi;
     277        pdi=(DECLAREINFO *)pInfo;
     278
     279        ret_type=pdi->ReturnType;
     280        *plpRetIndex=pdi->u.ReturnIndex;
     281    }
     282    else if(idProc==PROC_BUILTIN){
     283        /////////////////////////
     284        // 組み込み関数
     285        /////////////////////////
     286        int FuncId;
     287        FuncId=(int)(_int64)pInfo;
     288
     289        ret_type=GetFunctionType(FuncId);
     290        *plpRetIndex=-1;
     291    }
     292    else if(idProc==PROC_PTR){
     293        /////////////////
     294        // 関数ポインタ
     295        /////////////////
     296
     297        LONG_PTR lpIndex;
     298        GetVarType(name,&lpIndex,0);
     299
     300        extern PROCPTRINFO *pProcPtrInfo;
     301        ret_type=pProcPtrInfo[lpIndex].ReturnType;
     302        *plpRetIndex=pProcPtrInfo[lpIndex].u.ReturnIndex;
     303    }
     304
     305    return ret_type;
     306}
     307BOOL GetReturnTypeOfPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo){
     308    //プロパティ用のメソッドを呼び出す
     309
     310    //配列要素を取得
     311    char VarName[VN_SIZE],ArrayElements[VN_SIZE];
     312    GetArrayElement(variable,VarName,ArrayElements);
     313
     314    //オブジェクト名を取得
     315    char ObjectName[VN_SIZE];
     316    int RefType;
     317    SplitObjectName(VarName,ObjectName,&RefType);
     318
     319    //オーバーロード用の関数リストを作成
     320    std::vector<SUBINFO *> subs;
     321    GetOverloadSubHash(VarName,subs);
     322    if(subs.size()==0){
     323        return 0;
     324    }
     325
     326    //パラメータを整備
     327    char *Parameter;
     328    Parameter=(char *)HeapAlloc(hHeap,0,lstrlen(ArrayElements)+lstrlen(RightSide)+32);
     329    lstrcpy(Parameter,ArrayElements);
     330    if(RightSide){
     331        if(Parameter[0]&&RightSide[0]) lstrcat(Parameter,",");
     332        lstrcat(Parameter,RightSide);
     333    }
     334
     335    //オーバーロードを解決
     336    SUBINFO *psi;
     337    psi=OverloadSolutionWithStrParam(VarName,subs,Parameter,ObjectName,NULL);
    214338
    215339    if(psi){
    … …  
    225349//インデクサ（getter）の戻り値を取得
    226350bool GetReturnTypeOfIndexerGetterProc(CClass *pobj_Class,TYPEINFO &RetTypeInfo){
    227     SUBINFO **ppsi;
    228     int num;
    229     ppsi=pobj_Class->GetOperatorSubInfo(CALC_ARRAY_GET,num);
    230     if(num==0){
    231         HeapDefaultFree(ppsi);
    232 
     351    std::vector<SUBINFO *> subs;
     352    pobj_Class->EnumMethod( CALC_ARRAY_GET, subs );
     353    if( subs.size() == 0 ){
    233354        return false;
    234355    }
    235356
    236     RetTypeInfo.type = ppsi[0]->ReturnType;
    237     RetTypeInfo.u.lpIndex = ppsi[0]->u.ReturnIndex;
    238 
    239     HeapDefaultFree(ppsi);
     357    RetTypeInfo.type = subs[0]->ReturnType;
     358    RetTypeInfo.u.lpIndex = subs[0]->u.ReturnIndex;
    240359
    241360    return true;

  • BasicCompiler_Common/calculation.cpp

    r49 r50  
    11991199    BOOL bRet=0;
    12001200
    1201     SUBINFO **ppsi;
    1202     int num;
    1203     ppsi=pobj_c->GetOperatorSubInfo(CALC_SUBSITUATION,num);
    1204     if(num==0){
     1201    std::vector<SUBINFO *> subs;
     1202    pobj_c->EnumMethod( CALC_SUBSITUATION, subs );
     1203    if( subs.size() == 0 ){
    12051204        bRet=0;
    12061205        goto finish;
    12071206    }
    12081207
    1209     int i;
    1210     for(i=0;i<num;i++){
    1211         if(ppsi[i]->ParmNum==2){
    1212             TYPEINFO TypeInfo={ppsi[i]->pParmInfo[1].type,ppsi[i]->pParmInfo[1].u.index};
     1208    foreach( SUBINFO *psi, subs ){
     1209        if(psi->ParmNum==2){
     1210            TYPEINFO TypeInfo={psi->pParmInfo[1].type,psi->pParmInfo[1].u.index};
    12131211            if(IsStringObjectType(&TypeInfo)){
    12141212                bRet=1;
    … …  
    12191217
    12201218finish:
    1221     HeapDefaultFree(ppsi);
    12221219    return bRet;
    12231220}

  • BasicCompiler_Common/common.h

    r49 r50  
    1111#include <shlobj.h>
    1212#include <vector>
     13
     14//boost libraries
     15#include <boost/foreach.hpp>
     16
     17#define foreach BOOST_FOREACH
    1318
    1419#ifdef _AMD64_
    … …  
    417422SUBINFO *GetSubHash(const char *name,BOOL bError=0);
    418423SUBINFO *GetMethodHash(char *ObjectName,char *MethodName,char *Parameter,BOOL bError=0);
    419 SUBINFO **GetOverloadObjectSubHash(char *name,CClass *pobj_c, int *pNum);
    420 SUBINFO **GetOverloadSubHash(const char *name,int *pNum);
     424void GetOverloadSubHash( const char *lpszName, std::vector<SUBINFO *> &subs );
    421425
    422426//Object.cpp
    … …  
    424428int GetSizeOfClass(CClass *pobj_c);
    425429void AddClassName(char *Parameter,int NowLine);
    426 void CallConstractor(char *VarName,int *SubScripts,TYPEINFO &TypeInfo,char *Parameter);
     430void CallConstructor(char *VarName,int *SubScripts,TYPEINFO &TypeInfo,char *Parameter);
    427431
    428432//Overload.sbp
    429 SUBINFO *OverloadSolutionWithStrParam(char *name,SUBINFO **ppsi,int num,char *Parameter,char *ObjectName,TYPEINFO *pReturnTypeInfo);
    430 SUBINFO *OverloadSolution(const char *name,SUBINFO **ppsi,int num,PARAMETER_INFO *ppi,int ParmNum,TYPEINFO *pReturnTypeInfo);
     433SUBINFO *OverloadSolutionWithStrParam(
     434    const char *name,
     435    std::vector<SUBINFO *> &subs,
     436    const char *Parameter,
     437    const char *ObjectName,
     438    TYPEINFO *pReturnTypeInfo);
     439SUBINFO *OverloadSolution(
     440    const char *name,
     441    std::vector<SUBINFO *> &subs,
     442    const PARAMETER_INFO *ppi,
     443    const int ParmNum,
     444    TYPEINFO *pReturnTypeInfo);
    431445
    432446//Debug.cpp
    … …  
    550564void SplitObjectName(const char *name,char *ObjectName,int *pRefType);
    551565bool SplitMemberName( const char *desc, char *object, char *member );
     566int CallProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex);
     567BOOL CallPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo);
    552568int GetReturnTypeOfProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex);
    553569BOOL GetReturnTypeOfPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo);

  • BasicCompiler_Common/hash.cpp

    r47 r50  
    5353}
    5454
    55 SUBINFO **GetOverloadObjectSubHash(char *name,CClass *pobj_c, int *pNum){
    56     int i;
    57 
    58 
    59     //格納のための構造体配列を用意
    60     extern HANDLE hHeap;
    61     SUBINFO **ppArray_si;
    62     int num=0;
    63     ppArray_si=(SUBINFO **)HeapAlloc(hHeap,0,sizeof(SUBINFO *)*1024);
    64 
    65 
    66     //オブジェクトのメンバ関数の場合
    67     //※オーバーライドされた関数を先にサーチする必要があるため、バックサーチを行う
    68     for(i=pobj_c->iMethodNum-1;i>=0;i--){
    69         if(lstrcmp(name,pobj_c->ppobj_Method[i]->psi->name)==0){
    70             ppArray_si[num]=pobj_c->ppobj_Method[i]->psi;
    71             num++;
    72         }
    73     }
    74 
    75     *pNum=num;
    76     return ppArray_si;
    77 }
    78 
    79 SUBINFO **GetOverloadSubHash( const char *lpszName, int *pNum ){
     55void GetOverloadSubHash( const char *lpszName, std::vector<SUBINFO *> &subs ){
    8056    extern SUBINFO *pSubInfo;
    8157    extern int SubInfoNum;
    … …  
    9066    }
    9167    else lstrcpy(name,lpszName);
    92 
    93 
    94     //格納のための構造体配列を用意
    95     extern HANDLE hHeap;
    96     SUBINFO **ppArray_si;
    97     int num=0;
    98     ppArray_si=(SUBINFO **)HeapAlloc(hHeap,0,sizeof(SUBINFO *)*1024);
    9968
    10069
    … …  
    12291                }
    12392                else{
    124                     goto finish;
     93                    return;
    12594                }
    12695            }
    … …  
    12998        if( isStatic ){
    13099            // 静的メソッドから取得
    131             for(i=0;i<pobj_c->iStaticMethodNum;i++){
    132                 if(lstrcmp(NestMember,pobj_c->ppobj_StaticMethod[i]->psi->name)==0){
    133                     ppArray_si[num]=pobj_c->ppobj_StaticMethod[i]->psi;
    134                     num++;
    135                 }
    136             }
     100            pobj_c->EnumStaticMethod( NestMember, subs );
    137101        }
    138102        else{
    … …  
    142106            for(i=pobj_c->iMethodNum-1;i>=0;i--){
    143107                if(lstrcmp(NestMember,pobj_c->ppobj_Method[i]->psi->name)==0){
    144                     ppArray_si[num]=pobj_c->ppobj_Method[i]->psi;
    145                     num++;
     108                    subs.push_back( pobj_c->ppobj_Method[i]->psi );
    146109                }
    147110            }
    … …  
    161124            CClass *pobj_c = pobj_CompilingClass;
    162125
    163             for(i=0;i<pobj_c->iStaticMethodNum;i++){
    164                 if(lstrcmp(name,pobj_c->ppobj_StaticMethod[i]->psi->name)==0){
    165                     ppArray_si[num]=pobj_c->ppobj_StaticMethod[i]->psi;
    166                     num++;
    167                 }
    168             }
     126            pobj_c->EnumStaticMethod( NestMember, subs );
    169127
    170128
    … …  
    178136            for(;i<pobj_CompilingClass->iMethodNum;i++){
    179137                if(lstrcmp(name,pobj_CompilingClass->ppobj_Method[i]->psi->name)==0){
    180                     ppArray_si[num]=pobj_CompilingClass->ppobj_Method[i]->psi;
    181                     num++;
     138                    subs.push_back( pobj_CompilingClass->ppobj_Method[i]->psi );
    182139                }
    183140            }
    … …  
    188145                if(pobj_CompilingClass->ppobj_Method[i]->pobj_InheritsClass){
    189146                    if(lstrcmp(name,pobj_CompilingClass->ppobj_Method[i]->psi->name)==0){
    190                         ppArray_si[num]=pobj_CompilingClass->ppobj_Method[i]->psi;
    191                         num++;
     147                        subs.push_back( pobj_CompilingClass->ppobj_Method[i]->psi );
    192148                    }
    193149                }
    … …  
    211167            if(!psi->pobj_ParentClass){
    212168                if(lstrcmp(psi->name,name)==0){
    213                     ppArray_si[num]=psi;
    214                     num++;
     169                    subs.push_back( psi );
    215170                }
    216171            }
    … …  
    220175
    221176    }
    222 finish:
    223 
    224     *pNum=num;
    225     return ppArray_si;
    226177}
    227178
    228179//オーバーロードされていない関数を取得（昔のコンパイラソースコードとの互換性保持）
    229180SUBINFO *GetSubHash(const char *lpszName,BOOL bError){
    230     int num;
    231     SUBINFO **ppsi,*psi;
    232     ppsi = GetOverloadSubHash(lpszName,&num);
     181    std::vector<SUBINFO *> subs;
     182    GetOverloadSubHash(lpszName,subs);
    233183
    234184    //関数が存在しないとき
    235     if(num == 0){
    236         HeapDefaultFree(ppsi);
     185    if(subs.size() == 0){
    237186        return 0;
    238187    }
    239188
    240189    //一つ以上の関数が存在するときは内部エラー（デバッグ用）
    241     if(num > 1){
     190    if(subs.size() > 1){
    242191        if(bError) SetError(300,NULL,cp);
    243192    }
    244193
    245     psi = ppsi[0];
    246 
    247     HeapDefaultFree(ppsi);
     194    SUBINFO *psi;
     195    psi = subs[0];
    248196
    249197    return psi;
    … …  
    253201    sprintf(temporary,"%s.%s",ObjectName,MethodName);
    254202
    255     int num;
    256     SUBINFO **ppsi,*psi;
    257     ppsi = GetOverloadSubHash(temporary,&num);
     203    std::vector<SUBINFO *> subs;
     204    SUBINFO *psi;
     205    GetOverloadSubHash(temporary,subs);
    258206
    259207    //関数が存在しないとき
    260     if(num == 0){
    261         HeapDefaultFree(ppsi);
     208    if(subs.size() == 0){
    262209        return 0;
    263210    }
    264211
    265212    //オーバーロードを解決
    266     psi=OverloadSolutionWithStrParam(temporary,ppsi,num,Parameter,ObjectName,NULL);
    267     HeapDefaultFree(ppsi);
     213    psi=OverloadSolutionWithStrParam(temporary,subs,Parameter,ObjectName,NULL);
    268214
    269215    return psi;
Note: See TracChangeset for help on using the changeset viewer.