Changeset 50 in dev for BasicCompiler32


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

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

Location:
BasicCompiler32
Files:
10 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}
Note: See TracChangeset for help on using the changeset viewer.