Ignore:
Timestamp:
Mar 16, 2007, 11:07:14 PM (17 years ago)
Author:
dai_9181
Message:

Parameterクラスを適用。32bit側は動くようになったので、64bitのほうを調整する。

File:
1 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler_Common/Subroutine.cpp

    r69 r73  
    88
    99//コンパイル中の関数情報
    10 SUBINFO *pCompilingSubInfo;
     10SubInfo *pCompilingSubInfo;
    1111
    1212int GetCallProcName(char *buffer,char *name){
    … …  
    114114        /////////////////////
    115115
    116         SUBINFO *psi;
    117         psi=(SUBINFO *)pInfo;
     116        SubInfo *pSub;
     117        pSub=(SubInfo *)pInfo;
    118118
    119119        //GetSubHash内でエラー提示が行われた場合
    120         if(psi==(SUBINFO *)-1) return -1;
     120        if(pSub==(SubInfo *)-1) return -1;
    121121
    122122
    … …  
    131131        ////////////////////////
    132132
    133         std::vector<SUBINFO *> subs;
     133        std::vector<SubInfo *> subs;
    134134        GetOverloadSubHash(name,subs);
    135135        if(subs.size()){
    136136            //オーバーロードを解決
    137             psi=OverloadSolutionWithStrParam(name,subs,Parameter,ObjectName,NULL);
    138 
    139             if(!psi) return 0;
    140         }
    141 
    142 
    143         Opcode_CallProc(Parameter,psi,0,ObjectName,RefType);
     137            pSub=OverloadSolutionWithStrParam(name,subs,Parameter,ObjectName,NULL);
     138
     139            if(!pSub) return 0;
     140        }
     141
     142
     143        Opcode_CallProc(Parameter,pSub,0,ObjectName,RefType);
    144144        if( plpRetIndex ){
    145             *plpRetIndex = psi->u.ReturnIndex;
    146         }
    147         return psi->ReturnType;
     145            *plpRetIndex = pSub->u.ReturnIndex;
     146        }
     147        return pSub->ReturnType;
    148148    }
    149149    else if(idProc==PROC_DLL){
    … …  
    197197
    198198    //オーバーロード用の関数リストを作成
    199     std::vector<SUBINFO *> subs;
     199    std::vector<SubInfo *> subs;
    200200    GetOverloadSubHash(VarName,subs);
    201201    if(subs.size()==0){
    … …  
    213213
    214214    //オーバーロードを解決
    215     SUBINFO *psi;
    216     psi=OverloadSolutionWithStrParam(VarName,subs,Parameter,ObjectName,NULL);
    217 
    218     if(psi){
     215    SubInfo *pSub;
     216    pSub=OverloadSolutionWithStrParam(VarName,subs,Parameter,ObjectName,NULL);
     217
     218    if(pSub){
    219219        //呼び出し
    220         Opcode_CallProc(Parameter,psi,0,ObjectName,RefType);
     220        Opcode_CallProc(Parameter,pSub,0,ObjectName,RefType);
    221221
    222222        if( pRetTypeInfo ){
    223             pRetTypeInfo->type = psi->ReturnType;
    224             pRetTypeInfo->u.lpIndex = psi->u.ReturnIndex;
     223            pRetTypeInfo->type = pSub->ReturnType;
     224            pRetTypeInfo->u.lpIndex = pSub->u.ReturnIndex;
    225225        }
    226226    }
    … …  
    240240        /////////////////////
    241241
    242         SUBINFO *psi;
    243         psi=(SUBINFO *)pInfo;
     242        SubInfo *pSub;
     243        pSub=(SubInfo *)pInfo;
    244244
    245245        //GetSubHash内でエラー提示が行われた場合
    246         if(psi==(SUBINFO *)-1) return -1;
     246        if(pSub==(SubInfo *)-1) return -1;
    247247
    248248
    … …  
    257257        ////////////////////////
    258258
    259         std::vector<SUBINFO *> subs;
     259        std::vector<SubInfo *> subs;
    260260        GetOverloadSubHash(name,subs);
    261261        if( subs.size() > 0 ){
    262262            //オーバーロードを解決
    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;
     263            pSub=OverloadSolutionWithStrParam(name,subs,Parameter,ObjectName,NULL);
     264
     265            if(!pSub) return 0;
     266        }
     267
     268
     269        ret_type=pSub->ReturnType;
     270        *plpRetIndex=pSub->u.ReturnIndex;
    271271    }
    272272    else if(idProc==PROC_DLL){
    … …  
    318318
    319319    //オーバーロード用の関数リストを作成
    320     std::vector<SUBINFO *> subs;
     320    std::vector<SubInfo *> subs;
    321321    GetOverloadSubHash(VarName,subs);
    322322    if(subs.size()==0){
    … …  
    334334
    335335    //オーバーロードを解決
    336     SUBINFO *psi;
    337     psi=OverloadSolutionWithStrParam(VarName,subs,Parameter,ObjectName,NULL);
    338 
    339     if(psi){
     336    SubInfo *pSub;
     337    pSub=OverloadSolutionWithStrParam(VarName,subs,Parameter,ObjectName,NULL);
     338
     339    if(pSub){
    340340        if(pRetTypeInfo){
    341             pRetTypeInfo->type=psi->ReturnType;
    342             pRetTypeInfo->u.lpIndex=psi->u.ReturnIndex;
     341            pRetTypeInfo->type=pSub->ReturnType;
     342            pRetTypeInfo->u.lpIndex=pSub->u.ReturnIndex;
    343343        }
    344344    }
    … …  
    349349//インデクサ（getter）の戻り値を取得
    350350bool GetReturnTypeOfIndexerGetterProc(CClass *pobj_Class,TYPEINFO &RetTypeInfo){
    351     std::vector<SUBINFO *> subs;
     351    std::vector<SubInfo *> subs;
    352352    pobj_Class->EnumMethod( CALC_ARRAY_GET, subs );
    353353    if( subs.size() == 0 ){
    … …  
    644644    return 0;
    645645}
    646 SUBINFO *AddSubData(char *buffer,int NowLine,BOOL bVirtual,CClass *pobj_c,BOOL bStatic){
     646SubInfo *AddSubData(char *buffer,int NowLine,BOOL bVirtual,CClass *pobj_c,BOOL bStatic){
    647647    int i,i2,i3,sw;
    648648    DWORD dwType;
    … …  
    761761    SubNum++;
    762762
    763     SUBINFO *psi;
    764     psi=(SUBINFO *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,sizeof(SUBINFO));
     763    SubInfo *pSub = new SubInfo();
    765764
    766765    //クラス名
    767     psi->pobj_ParentClass=pobj_c;
     766    pSub->pobj_ParentClass=pobj_c;
    768767
    769768    //ID
    770769    static int id_base=0;
    771     psi->id=(id_base++);
     770    pSub->id=(id_base++);
    772771
    773772    //関数名
    774     psi->name=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
    775     lstrcpy(psi->name,temporary);
     773    pSub->name=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
     774    lstrcpy(pSub->name,temporary);
    776775
    777776    //ソースコードの位置
    778     psi->address=NowLine;
    779 
    780     psi->bExport=bExport;
    781     psi->bCdecl=bCdecl;
    782     psi->bVirtual=bVirtual;
    783     if(bExport) psi->bUse=1;
    784     else psi->bUse=0;
    785     psi->bCompile=0;
    786     psi->bSystem=0;
    787 
    788     psi->dwType=dwType;
    789 
    790 
    791     if(psi->dwType==SUBTYPE_FUNCTION){
     777    pSub->address=NowLine;
     778
     779    pSub->bExport=bExport;
     780    pSub->bCdecl=bCdecl;
     781    pSub->bVirtual=bVirtual;
     782    if(bExport) pSub->bUse=1;
     783    else pSub->bUse=0;
     784    pSub->bCompile=0;
     785    pSub->bSystem=0;
     786
     787    pSub->dwType=dwType;
     788
     789
     790    if(pSub->dwType==SUBTYPE_FUNCTION){
    792791        ///////////////////
    793792        // 戻り値を取得
    794793        ///////////////////
    795794
    796         psi->isReturnRef = false;
     795        pSub->isReturnRef = false;
    797796
    798797        if(pobj_c){
    799             if(lstrcmp(psi->name,pobj_c->name)==0||
    800                 psi->name[0]=='~'){
     798            if(lstrcmp(pSub->name,pobj_c->name)==0||
     799                pSub->name[0]=='~'){
    801800                //クラスのコンストラクタ、デストラクタがFunction定義の場合はエラーをだす
    802801                SetError(115,NULL,NowLine);
    … …  
    814813                if( buffer[i2-2] == 1 && buffer[i2-1] == ESC_BYREF ){
    815814                    //参照型
    816                     psi->isReturnRef = true;
     815                    pSub->isReturnRef = true;
    817816                }
    818817
    … …  
    827826                    temporary[i3]=buffer[i2];
    828827                }
    829                 psi->ReturnType=GetTypeFixed(temporary,&psi->u.ReturnIndex);
    830                 if(psi->ReturnType==DEF_NON) SetError(3,temporary,NowLine);
     828                pSub->ReturnType=GetTypeFixed(temporary,&pSub->u.ReturnIndex);
     829                if(pSub->ReturnType==DEF_NON) SetError(3,temporary,NowLine);
    831830
    832831                sw_as=1;
    … …  
    836835
    837836        if(!sw_as){
    838             SetError(-104,psi->name,NowLine);
    839 
    840             psi->ReturnType=DEF_DOUBLE;
     837            SetError(-104,pSub->name,NowLine);
     838
     839            pSub->ReturnType=DEF_DOUBLE;
    841840        }
    842841    }
    843842    else{
    844843        //戻り値なしのSub定義
    845         psi->ReturnType=DEF_NON;
    846         psi->u.ReturnIndex=-1;
    847     }
    848 
    849 
    850 
    851     psi->pParmInfo=(PARAMETER_INFO *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,sizeof(PARAMETER_INFO)*2);
    852     psi->ParmNum=0;
     844        pSub->ReturnType=DEF_NON;
     845        pSub->u.ReturnIndex=-1;
     846    }
    853847
    854848    //パラメータ
    … …  
    860854    if(buffer[i]!=')'&&pobj_c){
    861855        //クラスのメンバ関数の場合のみ、デストラクタにパラメータがある場合にエラーをだす
    862         if(psi->name[0]=='~'){
     856        if(pSub->name[0]=='~'){
    863857            SetError(114,NULL,NowLine);
    864858            i=JumpStringInPare(buffer,i);
    … …  
    868862        if(buffer[i]==')') break;
    869863
    870         psi->pParmInfo=(PARAMETER_INFO *)HeapReAlloc(hHeap,0,psi->pParmInfo,(psi->ParmNum+1)*sizeof(PARAMETER_INFO));
    871 
    872         //ByVal
     864        //ByRef
     865        bool isRef;
    873866        if(buffer[i]==1&&buffer[i+1]==ESC_BYVAL){
    874             psi->pParmInfo[psi->ParmNum].bByVal=1;
     867            isRef = false;
    875868            i+=2;
    876869        }
    877870        else if(buffer[i]==1&&buffer[i+1]==ESC_BYREF){
    878             psi->pParmInfo[psi->ParmNum].bByVal=0;
     871            isRef = true;
    879872            i+=2;
    880873        }
    881         else psi->pParmInfo[psi->ParmNum].bByVal=1;
     874        else isRef = false;
    882875
    883876        //パラメータ名
     877        bool isArray = false;
     878        int subScripts[MAX_ARRAYDIM];
     879        char name[VN_SIZE];
    884880        sw=0;
    885881        for(i2=0;;i++,i2++){
    … …  
    887883                if(!sw) sw=1;
    888884
    889                 i3=GetStringInPare(temporary+i2,buffer+i);
     885                i3=GetStringInPare(name+i2,buffer+i);
    890886                i2+=i3-1;
    891887                i+=i3-1;
    … …  
    895891                if(!sw) sw=1;
    896892
    897                 i3=GetStringInBracket(temporary+i2,buffer+i);
     893                i3=GetStringInBracket(name+i2,buffer+i);
    898894                i2+=i3-1;
    899895                i+=i3-1;
    … …  
    901897            }
    902898            if(!IsVariableChar(buffer[i])){
    903                 temporary[i2]=0;
     899                name[i2]=0;
    904900                break;
    905901            }
    906             temporary[i2]=buffer[i];
     902            name[i2]=buffer[i];
    907903        }
    908904        if(sw){
    909905            //配列パラメータ
    910             if(psi->pParmInfo[psi->ParmNum].bByVal) SetError(29,NULL,NowLine);
    911             psi->pParmInfo[psi->ParmNum].bArray=1;
    912 
    913             if((temporary[i2-2]=='('&&temporary[i2-1]==')')||
    914                 (temporary[i2-2]=='['&&temporary[i2-1]==']')){
    915                 psi->pParmInfo[psi->ParmNum].SubScripts[0]=LONG_MAX;
    916                 psi->pParmInfo[psi->ParmNum].SubScripts[1]=-1;
    917 
    918                 temporary[i2-2]=0;
     906            if( isRef == false ) SetError(29,NULL,NowLine);
     907            isArray = true;
     908
     909            if((name[i2-2]=='('&&name[i2-1]==')')||
     910                (name[i2-2]=='['&&name[i2-1]==']')){
     911                subScripts[0]=LONG_MAX;
     912                subScripts[1]=-1;
     913
     914                name[i2-2]=0;
    919915            }
    920916            else{
    921                 GetArrange(temporary,temp2,psi->pParmInfo[psi->ParmNum].SubScripts);
    922                 lstrcpy(temporary,temp2);
    923             }
    924 
    925             i2=lstrlen(temporary);
    926         }
    927         else{
    928             psi->pParmInfo[psi->ParmNum].bArray=0;
    929             psi->pParmInfo[psi->ParmNum].SubScripts[0]=-1;
    930         }
    931         psi->pParmInfo[psi->ParmNum].name=(char *)HeapAlloc(hHeap,0,i2+1);
    932         lstrcpy(psi->pParmInfo[psi->ParmNum].name,temporary);
     917                GetArrange(name,temp2,subScripts);
     918                lstrcpy(name,temp2);
     919            }
     920
     921            i2=lstrlen(name);
     922        }
    933923
    934924        //型
     925        Type type( DEF_NON );
    935926        if(buffer[i]==1&&buffer[i+1]==ESC_AS){
    936927            i+=2;
    … …  
    955946            }
    956947
    957             psi->pParmInfo[psi->ParmNum].type=
    958                 GetTypeFixed(temporary,&psi->pParmInfo[psi->ParmNum].u.index);
     948            Type::StringToType( temporary, type );
    959949
    960950            if(temporary[0]=='*'&&
    … …  
    963953                if(buffer[i]!='('){
    964954                    SetError(10,temporary,NowLine);
    965                     return 0;
     955                    break;
    966956                }
    967957                i3=GetStringInPare(temporary+i2,buffer+i);
    … …  
    986976            }
    987977
    988             if(psi->pParmInfo[psi->ParmNum].type==-1){
     978            if( type.IsNull() ){
    989979                SetError(3,temporary,NowLine);
    990                 psi->pParmInfo[psi->ParmNum].type=DEF_PTR_VOID;
    991             }
    992 
    993             /*未完成（構造体パラメータを値参照として渡してよいものか！？）
    994             if(psi->pParmInfo[psi->ParmNum].type==DEF_OBJECT){
    995                 if(psi->pParmInfo[psi->ParmNum].bByVal) SetError(28,temporary,NowLine);
    996             }*/
     980                type.SetBasicType( DEF_PTR_VOID );
     981            }
    997982        }
    998983        else{
    999             psi->pParmInfo[psi->ParmNum].type=GetTypeFromSimpleName(temporary);
     984            type.SetBasicType( GetTypeFromSimpleName(temporary) );
    1000985            SetError(-103,temporary,NowLine);
    1001986        }
    1002987
    1003         if(psi->pParmInfo[psi->ParmNum].type==DEF_PTR_PROC){
     988        if( type.IsProcPtr() ){
    1004989            //関数ポインタの場合
    1005             psi->pParmInfo[psi->ParmNum].u.index=AddProcPtrInfo(temporary+3,temporary[2]);
    1006         }
    1007 
    1008         //パラメータの数を更新
    1009         psi->ParmNum++;
     990            type.SetIndex( AddProcPtrInfo(temporary+3,temporary[2]) );
     991        }
     992
     993        Parameter *pParam = new Parameter( name, type, isRef );
     994        if( isArray ){
     995            pParam->SetArray( subScripts );
     996        }
     997
     998        //パラメータを追加
     999        pSub->params.push_back( pParam );
    10101000
    10111001        if(buffer[i]==','){
    … …  
    10161006        else{
    10171007            SetError(1,NULL,NowLine);
    1018             return 0;
    1019         }
    1020     }
    1021     psi->SecondParmNum=psi->ParmNum;
     1008            break;
     1009        }
     1010    }
     1011    pSub->SecondParmNum = (int)pSub->params.size();
    10221012    i++;
    10231013    if(buffer[i]=='('){
    … …  
    10261016            if(buffer[i]==')') break;
    10271017
    1028             psi->pParmInfo=(PARAMETER_INFO *)HeapReAlloc(hHeap,0,psi->pParmInfo,(psi->ParmNum+1)*sizeof(PARAMETER_INFO));
    1029 
    1030             //ByVal
     1018            //ByRef
     1019            bool isRef;
    10311020            if(buffer[i]==1&&buffer[i+1]==ESC_BYVAL){
    1032                 psi->pParmInfo[psi->ParmNum].bByVal=1;
     1021                isRef = false;
    10331022                i+=2;
    10341023            }
    10351024            else if(buffer[i]==1&&buffer[i+1]==ESC_BYREF){
    1036                 psi->pParmInfo[psi->ParmNum].bByVal=0;
     1025                isRef = true;
    10371026                i+=2;
    10381027            }
    1039             else psi->pParmInfo[psi->ParmNum].bByVal=1;
     1028            else isRef = false;
    10401029
    10411030            //パラメータ名
     1031            bool isArray = false;
     1032            int subScripts[MAX_ARRAYDIM];
     1033            char name[VN_SIZE];
    10421034            sw=0;
    10431035            for(i2=0;;i++,i2++){
    … …  
    10451037                    if(!sw) sw=1;
    10461038
    1047                     i3=GetStringInPare(temporary+i2,buffer+i);
     1039                    i3=GetStringInPare(name+i2,buffer+i);
    10481040                    i2+=i3-1;
    10491041                    i+=i3-1;
    … …  
    10531045                    if(!sw) sw=1;
    10541046
    1055                     i3=GetStringInBracket(temporary+i2,buffer+i);
     1047                    i3=GetStringInBracket(name+i2,buffer+i);
    10561048                    i2+=i3-1;
    10571049                    i+=i3-1;
    … …  
    10591051                }
    10601052                if(!IsVariableChar(buffer[i])){
    1061                     temporary[i2]=0;
     1053                    name[i2]=0;
    10621054                    break;
    10631055                }
    1064                 temporary[i2]=buffer[i];
     1056                name[i2]=buffer[i];
    10651057            }
    10661058            if(sw){
    10671059                //配列パラメータ
    1068                 if(psi->pParmInfo[psi->ParmNum].bByVal) SetError(29,NULL,NowLine);
    1069                 psi->pParmInfo[psi->ParmNum].bArray=1;
    1070 
    1071                 if((temporary[i2-2]=='('&&temporary[i2-1]==')')||
    1072                     (temporary[i2-2]=='['&&temporary[i2-1]==']')){
    1073                     psi->pParmInfo[psi->ParmNum].SubScripts[0]=LONG_MAX;
    1074                     psi->pParmInfo[psi->ParmNum].SubScripts[1]=-1;
    1075 
    1076                     temporary[i2-2]=0;
     1060                if( isRef == false ) SetError(29,NULL,NowLine);
     1061                isArray = true;
     1062
     1063                if((name[i2-2]=='('&&name[i2-1]==')')||
     1064                    (name[i2-2]=='['&&name[i2-1]==']')){
     1065                    subScripts[0]=LONG_MAX;
     1066                    subScripts[1]=-1;
     1067
     1068                    name[i2-2]=0;
    10771069                }
    10781070                else{
    1079                     GetArrange(temporary,temp2,psi->pParmInfo[psi->ParmNum].SubScripts);
    1080                     lstrcpy(temporary,temp2);
    1081                 }
    1082 
    1083                 i2=lstrlen(temporary);
    1084             }
    1085             else{
    1086                 psi->pParmInfo[psi->ParmNum].bArray=0;
    1087                 psi->pParmInfo[psi->ParmNum].SubScripts[0]=-1;
    1088             }
    1089             psi->pParmInfo[psi->ParmNum].name=(char *)HeapAlloc(hHeap,0,i2+1);
    1090             lstrcpy(psi->pParmInfo[psi->ParmNum].name,temporary);
     1071                    GetArrange(name,temp2,subScripts);
     1072                    lstrcpy(name,temp2);
     1073                }
     1074
     1075                i2=lstrlen(name);
     1076            }
    10911077
    10921078            //型
     1079            Type type( DEF_NON );
    10931080            if(buffer[i]==1&&buffer[i+1]==ESC_AS){
    10941081                i+=2;
     1082
    10951083                i2=0;
    10961084                while(buffer[i]=='*'){
    … …  
    11011089                for(;;i++,i2++){
    11021090                    if(!IsVariableChar(buffer[i])){
     1091                        if(buffer[i]==1&&(buffer[i+1]==ESC_FUNCTION||buffer[i+1]==ESC_SUB)){
     1092                            temporary[i2++]=buffer[i++];
     1093                            temporary[i2]=buffer[i];
     1094                            continue;
     1095                        }
    11031096                        temporary[i2]=0;
    11041097                        break;
    … …  
    11061099                    temporary[i2]=buffer[i];
    11071100                }
    1108                 psi->pParmInfo[psi->ParmNum].type=
    1109                     GetTypeFixed(temporary,&psi->pParmInfo[psi->ParmNum].u.index);
    1110                 if(psi->pParmInfo[psi->ParmNum].type==-1) SetError(3,temporary,NowLine);
     1101
     1102                Type::StringToType( temporary, type );
     1103
     1104                if(temporary[0]=='*'&&
     1105                    temporary[1]==1&&
     1106                    (temporary[2]==ESC_FUNCTION||temporary[2]==ESC_SUB)){
     1107                    if(buffer[i]!='('){
     1108                        SetError(10,temporary,NowLine);
     1109                        break;
     1110                    }
     1111                    i3=GetStringInPare(temporary+i2,buffer+i);
     1112                    i+=i3;
     1113                    i2+=i3;
     1114
     1115                    if(temporary[2]==ESC_FUNCTION&&buffer[i]==1&&buffer[i+1]==ESC_AS){
     1116                        temporary[i2++]=buffer[i++];
     1117                        temporary[i2++]=buffer[i++];
     1118                        for(;;i++,i2++){
     1119                            if(!IsVariableChar(buffer[i])){
     1120                                temporary[i2]=0;
     1121                                break;
     1122                            }
     1123                            temporary[i2]=buffer[i];
     1124                        }
     1125                    }
     1126                }
     1127                else{
     1128                    //TypeDefをする前のベース型を取得
     1129                    GetOriginalTypeName(temporary);
     1130                }
     1131
     1132                if( type.IsNull() ){
     1133                    SetError(3,temporary,NowLine);
     1134                    type.SetBasicType( DEF_PTR_VOID );
     1135                }
    11111136            }
    11121137            else{
    1113                 psi->pParmInfo[psi->ParmNum].type=GetTypeFromSimpleName(temporary);
     1138                type.SetBasicType( GetTypeFromSimpleName(temporary) );
    11141139                SetError(-103,temporary,NowLine);
    11151140            }
    11161141
    1117             psi->ParmNum++;
     1142            if( type.IsProcPtr() ){
     1143                //関数ポインタの場合
     1144                type.SetIndex( AddProcPtrInfo(temporary+3,temporary[2]) );
     1145            }
     1146
     1147            Parameter *pParam = new Parameter( name, type, isRef );
     1148            if( isArray ){
     1149                pParam->SetArray( subScripts );
     1150            }
     1151
     1152            //パラメータを追加
     1153            pSub->params.push_back( pParam );
    11181154
    11191155            if(buffer[i]==','){
    … …  
    11241160            else{
    11251161                SetError(1,NULL,NowLine);
    1126                 return 0;
     1162                break;
    11271163            }
    11281164        }
    … …  
    11301166    }
    11311167
    1132     //リアルパラメータ領域を取得（_System_LocalThisを考慮して2つだけ多く確保する）
    1133     psi->pRealParmInfo=(PARAMETER_INFO *)HeapAlloc(hHeap,0,(psi->ParmNum+2)*sizeof(PARAMETER_INFO));
    1134     psi->RealParmNum=0;
     1168    //リアルパラメータ領域を取得（_System_LocalThisを考慮して2つだけ多く確保する場合がある）
    11351169
    11361170    if(pobj_c&&bStatic==0){
    1137         i = psi->RealParmNum;
    1138 
    11391171        //オブジェクトメンバの場合は、第一パラメータを_System_LocalThis引き渡し用として利用
    1140         psi->pRealParmInfo[i].name = "_System_LocalThis";
    1141         psi->pRealParmInfo[i].type=DEF_PTR_VOID;
    1142         psi->pRealParmInfo[i].u.index=-1;
    1143         psi->pRealParmInfo[i].bByVal=1;
    1144         psi->pRealParmInfo[i].bArray=0;
    1145         psi->pRealParmInfo[i].SubScripts[0]=-1;
    1146 
    1147         psi->RealParmNum++;
    1148     }
    1149 
    1150     if(psi->ReturnType==DEF_STRUCT){
    1151         i = psi->RealParmNum;
    1152 
     1172        string name = "_System_LocalThis";
     1173        Type type( DEF_PTR_VOID );
     1174        pSub->realParams.push_back( new Parameter( name, type ) );
     1175    }
     1176
     1177    if(pSub->ReturnType==DEF_STRUCT){
    11531178        //構造体を戻り値として持つ場合
    11541179        //※第一パラメータ（Thisポインタありの場合は第二パラメータ）を戻り値用の参照宣言にする
    11551180
    1156         if(psi->name[0]==1&&psi->name[1]==ESC_OPERATOR)
    1157             psi->pRealParmInfo[i].name="_System_ReturnValue";
    1158         else psi->pRealParmInfo[i].name=psi->name;
    1159         psi->pRealParmInfo[i].type=DEF_STRUCT;
    1160         psi->pRealParmInfo[i].u.index=psi->u.ReturnIndex;
    1161         psi->pRealParmInfo[i].bByVal=0;
    1162         psi->pRealParmInfo[i].bArray=0;
    1163         psi->pRealParmInfo[i].SubScripts[0]=-1;
    1164        
    1165         psi->RealParmNum++;
     1181        string name = pSub->name;
     1182        if(pSub->name[0]==1&&pSub->name[1]==ESC_OPERATOR){
     1183            name="_System_ReturnValue";
     1184        }
     1185        Type type( DEF_STRUCT, pSub->u.ReturnIndex );
     1186        pSub->realParams.push_back( new Parameter( name, type, true ) );
    11661187    }
    11671188
    11681189    //パラメータをコピー
    1169     for( i = 0; i < psi->ParmNum; i++, psi->RealParmNum++ ){
    1170         psi->pRealParmInfo[psi->RealParmNum]=psi->pParmInfo[i];
     1190    foreach( Parameter *pParam, pSub->params ){
     1191        pSub->realParams.push_back( new Parameter( *pParam ) );
    11711192    }
    11721193
    … …  
    11771198
    11781199    int key;
    1179     key=hash_default(psi->name);
    1180 
    1181     extern SUBINFO **ppSubHash;
     1200    key=hash_default(pSub->name);
     1201
     1202    extern SubInfo **ppSubHash;
    11821203    if(ppSubHash[key]){
    1183         SUBINFO *psi2;
     1204        SubInfo *psi2;
    11841205        psi2=ppSubHash[key];
    11851206        while(1){
    11861207            if(pobj_c==psi2->pobj_ParentClass){
    11871208                //重複エラーチェックを行う
    1188                 if(lstrcmp(psi2->name,psi->name)==0){
    1189                     if(CompareParameter(psi2->pParmInfo,psi2->ParmNum,psi->pParmInfo,psi->ParmNum)==0){
    1190                         SetError(15,psi->name,NowLine);
     1209                if(lstrcmp(psi2->name,pSub->name)==0){
     1210                    if( Parameter::Equals( psi2->params, pSub->params ) ){
     1211                        SetError(15,pSub->name,NowLine);
    11911212                        return 0;
    11921213                    }
    … …  
    11971218            psi2=psi2->pNextData;
    11981219        }
    1199         psi2->pNextData=psi;
     1220        psi2->pNextData=pSub;
    12001221    }
    12011222    else{
    1202         ppSubHash[key]=psi;
    1203     }
    1204 
    1205     return psi;
     1223        ppSubHash[key]=pSub;
     1224    }
     1225
     1226    return pSub;
    12061227}
    12071228
    … …  
    12171238
    12181239    //サブルーチン（ユーザー定義）情報を初期化
    1219     extern SUBINFO **ppSubHash;
     1240    extern SubInfo **ppSubHash;
    12201241    extern int SubNum;
    1221     ppSubHash=(SUBINFO **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(SUBINFO *));
     1242    ppSubHash=(SubInfo **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(SubInfo *));
    12221243    SubNum=0;
    12231244
    … …  
    13131334    AddSubData(temporary,0,0,0);
    13141335}
    1315 void Delete_si(SUBINFO *psi){
    1316     int i2;
    1317 
    1318     for(i2=0;i2<psi->ParmNum;i2++){
    1319         HeapDefaultFree(psi->pParmInfo[i2].name);
    1320     }
    1321     HeapDefaultFree(psi->pRealParmInfo);
    1322     if(psi->pParmInfo) HeapDefaultFree(psi->pParmInfo);
    1323     psi->pRealParmInfo=0;
    1324     psi->pParmInfo=0;
    1325 
    1326     if(psi->pNextData) Delete_si(psi->pNextData);
    1327 
    1328     HeapDefaultFree(psi->name);
    1329     HeapDefaultFree(psi);
    1330 }
    1331 void DeleteSubInfo(SUBINFO **ppSubHash,char **ppMacroNames,int MacroNum){   //サブルーチン情報のメモリ解放
     1336void Delete_si(SubInfo *pSub){
     1337    foreach( Parameter *pParam, pSub->params ){
     1338        delete pParam;
     1339    }
     1340
     1341    foreach( Parameter *pParam, pSub->realParams ){
     1342        delete pParam;
     1343    }
     1344
     1345    if(pSub->pNextData) Delete_si(pSub->pNextData);
     1346
     1347    HeapDefaultFree(pSub->name);
     1348    delete pSub;
     1349}
     1350void DeleteSubInfo(SubInfo **ppSubHash,char **ppMacroNames,int MacroNum){   //サブルーチン情報のメモリ解放
    13321351    int i;
    13331352    for(i=0;i<MAX_HASH;i++){
Note: See TracChangeset for help on using the changeset viewer.