source: dev/BasicCompiler_Common/Subroutine.cpp@ 50

#include "../BasicCompiler_Common/common.h"

#ifdef _AMD64_
#include "../BasicCompiler64/opcode.h"
#else
#include "../BasicCompiler32/opcode.h"
#endif

//コンパイル中の関数情報
SUBINFO *pCompilingSubInfo;

int GetCallProcName(char *buffer,char *name){
    int i2,i3,IsStr=0;

    for(i2=0;;i2++){
        if(buffer[i2]=='\"') IsStr^=1;
        if(IsDBCSLeadByte(buffer[i2])){
            name[i2]=buffer[i2];
            i2++;
            name[i2]=buffer[i2];
            continue;
        }
        if(buffer[i2]=='['&&IsStr==0){
            i3=GetStringInBracket(name+i2,buffer+i2);
            i2+=i3-1;
            continue;
        }
        if(buffer[i2]=='('&&IsStr==0){
            name[i2]=0;
            break;
        }
        if(buffer[i2]=='='&&IsStr==0){
            name[i2]=0;
            break;
        }

        name[i2]=buffer[i2];
        if(buffer[i2]=='\0') break;
    }
    return i2;
}

int GetProc(char *name,void **ppInfo){

    //ユーザー定義関数
    *ppInfo=(void *)GetSubHash(name);
    if(*ppInfo) return PROC_DEFAULT;

    //DLL関数
    *ppInfo=(void *)GetDeclareHash(name);
    if(*ppInfo) return PROC_DLL;

    //コンパイラ埋め込み型
    *ppInfo=(void *)(_int64)GetFunctionFromName(name);
    if(*ppInfo) return PROC_BUILTIN;

    //関数ポインタ
    int type;
    LONG_PTR lpIndex;
    type=GetVarType(name,&lpIndex,0);
    if(type==DEF_PTR_PROC) return PROC_PTR;

    return 0;
}

void SplitObjectName(const char *name,char *ObjectName,int *pRefType){
    int i4;
    for(i4=lstrlen(name)-1;i4>=0;i4--){
        if(name[i4]=='.'||(name[i4]==1&&name[i4+1]==ESC_PSMEM))
            break;
    }
    if(i4==-1) ObjectName[0]=0;
    else{
        //参照タイプを判別
        if(name[i4]=='.') *pRefType=DEF_OBJECT;
        else *pRefType=DEF_PTR_OBJECT;

        if(i4==0) GetWithName(ObjectName);
        else{
            memcpy(ObjectName,name,i4);
            ObjectName[i4]=0;
        }
    }
}
bool SplitMemberName( const char *desc, char *object, char *member ){
    int i;
    for(i=lstrlen(desc)-1;i>=0;i--){
        if(desc[i]=='.'||(desc[i]==1&&desc[i+1]==ESC_PSMEM))
            break;
    }
    if(i==-1) return false;
    else{
        if(desc[i]=='.')
            lstrcpy(member,desc+i+1);
        else
            lstrcpy(member,desc+i+2);

        if( object ){
            lstrcpy( object, desc );
            object[i]=0;
        }
    }

    return true;
}


int CallProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex){
    int ret_type;

    if(idProc==PROC_DEFAULT){
        /////////////////////
        // ユーザー定義関数
        /////////////////////

        SUBINFO *psi;
        psi=(SUBINFO *)pInfo;

        //GetSubHash内でエラー提示が行われた場合
        if(psi==(SUBINFO *)-1) return -1;


        //オブジェクト名を取得
        char ObjectName[VN_SIZE];
        int RefType;
        SplitObjectName(name,ObjectName,&RefType);


        ////////////////////////
        // オーバーロードを解決
        ////////////////////////

        std::vector<SUBINFO *> subs;
        GetOverloadSubHash(name,subs);
        if(subs.size()){
            //オーバーロードを解決
            psi=OverloadSolutionWithStrParam(name,subs,Parameter,ObjectName,NULL);

            if(!psi) return 0;
        }


        Opcode_CallProc(Parameter,psi,0,ObjectName,RefType);
        if( plpRetIndex ){
            *plpRetIndex = psi->u.ReturnIndex;
        }
        return psi->ReturnType;
    }
    else if(idProc==PROC_DLL){
        /////////////////////////
        // DLL関数
        /////////////////////////
        DECLAREINFO *pdi;
        pdi=(DECLAREINFO *)pInfo;

        ret_type=Opcode_CallDllProc(Parameter,pdi,plpRetIndex);
    }
    else if(idProc==PROC_BUILTIN){
        /////////////////////////
        // 組み込み関数
        /////////////////////////
        int FuncId;
        FuncId=(int)(_int64)pInfo;

        TYPEINFO ReturnTypeInfo = { DEF_LONG, NULL };
        Opcode_CallFunc( Parameter, FuncId, ReturnTypeInfo );
        if( plpRetIndex ){
            *plpRetIndex = ReturnTypeInfo.u.lpIndex;
        }
        return ReturnTypeInfo.type;
    }
    else if(idProc==PROC_PTR){
        /////////////////
        // 関数ポインタ
        /////////////////

        LONG_PTR lpIndex;
        GetVarType(name,&lpIndex,0);

        extern PROCPTRINFO *pProcPtrInfo;
        ret_type=Opcode_CallProcPtr(name,Parameter,&pProcPtrInfo[lpIndex],plpRetIndex);
    }

    return ret_type;
}
BOOL CallPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo){
    //プロパティ用のメソッドを呼び出す

    //配列要素を取得
    char VarName[VN_SIZE],ArrayElements[VN_SIZE];
    GetArrayElement(variable,VarName,ArrayElements);

    //オブジェクト名を取得
    char ObjectName[VN_SIZE];
    int RefType;
    SplitObjectName(VarName,ObjectName,&RefType);

    //オーバーロード用の関数リストを作成
    std::vector<SUBINFO *> subs;
    GetOverloadSubHash(VarName,subs);
    if(subs.size()==0){
        return 0;
    }

    //パラメータを整備
    char *Parameter;
    Parameter=(char *)HeapAlloc(hHeap,0,lstrlen(ArrayElements)+lstrlen(RightSide)+32);
    lstrcpy(Parameter,ArrayElements);
    if(RightSide){
        if(Parameter[0]&&RightSide[0]) lstrcat(Parameter,",");
        lstrcat(Parameter,RightSide);
    }

    //オーバーロードを解決
    SUBINFO *psi;
    psi=OverloadSolutionWithStrParam(VarName,subs,Parameter,ObjectName,NULL);

    if(psi){
        //呼び出し
        Opcode_CallProc(Parameter,psi,0,ObjectName,RefType);

        if( pRetTypeInfo ){
            pRetTypeInfo->type = psi->ReturnType;
            pRetTypeInfo->u.lpIndex = psi->u.ReturnIndex;
        }
    }

    HeapDefaultFree(Parameter);

    return 1;
}


int GetReturnTypeOfProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex){
    int ret_type;

    if(idProc==PROC_DEFAULT){
        /////////////////////
        // ユーザー定義関数
        /////////////////////

        SUBINFO *psi;
        psi=(SUBINFO *)pInfo;

        //GetSubHash内でエラー提示が行われた場合
        if(psi==(SUBINFO *)-1) return -1;


        //オブジェクト名を取得
        char ObjectName[VN_SIZE];
        int RefType;
        SplitObjectName(name,ObjectName,&RefType);


        ////////////////////////
        // オーバーロードを解決
        ////////////////////////

        std::vector<SUBINFO *> subs;
        GetOverloadSubHash(name,subs);
        if( subs.size() > 0 ){
            //オーバーロードを解決
            psi=OverloadSolutionWithStrParam(name,subs,Parameter,ObjectName,NULL);

            if(!psi) return 0;
        }


        ret_type=psi->ReturnType;
        *plpRetIndex=psi->u.ReturnIndex;
    }
    else if(idProc==PROC_DLL){
        /////////////////////////
        // DLL関数
        /////////////////////////
        DECLAREINFO *pdi;
        pdi=(DECLAREINFO *)pInfo;

        ret_type=pdi->ReturnType;
        *plpRetIndex=pdi->u.ReturnIndex;
    }
    else if(idProc==PROC_BUILTIN){
        /////////////////////////
        // 組み込み関数
        /////////////////////////
        int FuncId;
        FuncId=(int)(_int64)pInfo;

        ret_type=GetFunctionType(FuncId);
        *plpRetIndex=-1;
    }
    else if(idProc==PROC_PTR){
        /////////////////
        // 関数ポインタ
        /////////////////

        LONG_PTR lpIndex;
        GetVarType(name,&lpIndex,0);

        extern PROCPTRINFO *pProcPtrInfo;
        ret_type=pProcPtrInfo[lpIndex].ReturnType;
        *plpRetIndex=pProcPtrInfo[lpIndex].u.ReturnIndex;
    }

    return ret_type;
}
BOOL GetReturnTypeOfPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo){
    //プロパティ用のメソッドを呼び出す

    //配列要素を取得
    char VarName[VN_SIZE],ArrayElements[VN_SIZE];
    GetArrayElement(variable,VarName,ArrayElements);

    //オブジェクト名を取得
    char ObjectName[VN_SIZE];
    int RefType;
    SplitObjectName(VarName,ObjectName,&RefType);

    //オーバーロード用の関数リストを作成
    std::vector<SUBINFO *> subs;
    GetOverloadSubHash(VarName,subs);
    if(subs.size()==0){
        return 0;
    }

    //パラメータを整備
    char *Parameter;
    Parameter=(char *)HeapAlloc(hHeap,0,lstrlen(ArrayElements)+lstrlen(RightSide)+32);
    lstrcpy(Parameter,ArrayElements);
    if(RightSide){
        if(Parameter[0]&&RightSide[0]) lstrcat(Parameter,",");
        lstrcat(Parameter,RightSide);
    }

    //オーバーロードを解決
    SUBINFO *psi;
    psi=OverloadSolutionWithStrParam(VarName,subs,Parameter,ObjectName,NULL);

    if(psi){
        if(pRetTypeInfo){
            pRetTypeInfo->type=psi->ReturnType;
            pRetTypeInfo->u.lpIndex=psi->u.ReturnIndex;
        }
    }

    return 1;
}

//インデクサ（getter）の戻り値を取得
bool GetReturnTypeOfIndexerGetterProc(CClass *pobj_Class,TYPEINFO &RetTypeInfo){
    std::vector<SUBINFO *> subs;
    pobj_Class->EnumMethod( CALC_ARRAY_GET, subs );
    if( subs.size() == 0 ){
        return false;
    }

    RetTypeInfo.type = subs[0]->ReturnType;
    RetTypeInfo.u.lpIndex = subs[0]->u.ReturnIndex;

    return true;
}


void AddDeclareData(char *buffer,int NowLine){
    extern HANDLE hHeap;
    int i,i2,i3,i4,sw,IsFunction;
    char temporary[VN_SIZE];

    i=0;

    DWORD dwType;
    BOOL bCdecl=0;

    //Static/Dynamic
    if(buffer[i]==ESC_STATIC){
        dwType=DECLARE_STATIC;
        i++;
    }
    else dwType=DECLARE_DYNAMIC;

    //Sub/Function
    if(buffer[i]==ESC_SUB) IsFunction=0;
    else if(buffer[i]==ESC_FUNCTION) IsFunction=1;
    else{
        SetError(1,NULL,NowLine);
        return;
    }
    i++;

    //プロシージャ名
    for(i2=0;;i++,i2++){
        if(buffer[i]==1&&buffer[i+1]==ESC_CDECL){
            bCdecl=1;

            i+=2;
            temporary[i2]=0;
            break;
        }
        if(buffer[i]==','){
            temporary[i2]=0;
            break;
        }
        if(buffer[i]=='\0'){
            SetError(1,NULL,NowLine);
            return;
        }
        temporary[i2]=buffer[i];
    }

    //ユーザー定義関数との重複チェック
    if(GetSubHash(temporary)){
        SetError(15,temporary,NowLine);
        return;
    }


    /////////////////////////////////
    // 格納位置を計算してpciにセット
    /////////////////////////////////

    //ハッシュ値を取得
    int key;
    key=hash_default(temporary);

    extern DECLAREINFO **ppDeclareHash;
    DECLAREINFO *pdi;
    if(ppDeclareHash[key]){
        pdi=ppDeclareHash[key];
        while(1){
            if(lstrcmpi(pdi->name,temporary)==0){
                //重複エラー
                SetError(15,temporary,NowLine);
                return;
            }

            if(pdi->pNextData==0){
                pdi->pNextData=(DECLAREINFO *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,sizeof(DECLAREINFO));
                break;
            }
            pdi=pdi->pNextData;
        }
        pdi=pdi->pNextData;
    }
    else{
        ppDeclareHash[key]=(DECLAREINFO *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,sizeof(DECLAREINFO));
        pdi=ppDeclareHash[key];
    }

    pdi->dwType=dwType;
    pdi->bCdecl=bCdecl;

    pdi->name=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
    lstrcpy(pdi->name,temporary);
    i++;

    //ライブラリ
    if(buffer[i]!='\"'){
        SetError(1,NULL,NowLine);
        return;
    }
    for(i++,i2=0;;i++,i2++){
        if(buffer[i]=='\"'){
            temporary[i2]=0;
            break;
        }
        if(buffer[i]=='\0'){
            SetError(1,NULL,NowLine);
            return;
        }
        temporary[i2]=buffer[i];
    }
    CharUpper(temporary);
    if(!strstr(temporary,".")){
        if(pdi->dwType==DECLARE_STATIC) lstrcat(temporary,".LIB");
        else{
            lstrcat(temporary,".DLL");
            if(lstrlen(temporary)>=16){
                SetError(7,NULL,NowLine);
                return;
            }
        }
    }
    pdi->file=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
    lstrcpy(pdi->file,temporary);
    i++;

    if(buffer[i]==','){
        i++;
        if(buffer[i]!='\"'){
            SetError(1,NULL,NowLine);
            return;
        }
        for(i++,i2=0;;i++,i2++){
            if(buffer[i]=='\"'){
                temporary[i2]=0;
                break;
            }
            if(buffer[i]=='\0'){
                SetError(1,NULL,NowLine);
                return;
            }
            temporary[i2]=buffer[i];
        }
        pdi->alias=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
        lstrcpy(pdi->alias,temporary);
        i++;
    }
    else{
        pdi->alias=(char *)HeapAlloc(hHeap,0,lstrlen(pdi->name)+1);
        lstrcpy(pdi->alias,pdi->name);
    }

    //パラメータの始めのカッコ
    if(buffer[i]!='('){
        SetError(1,NULL,NowLine);
        return;
    }
    i++;

    pdi->pParmInfo=(PARAMETER_INFO *)HeapAlloc(hHeap,0,1);

    //各パラメータ
    for(i3=0;;i3++){
        if(buffer[i]==')') break;

        pdi->pParmInfo=(PARAMETER_INFO *)HeapReAlloc(hHeap,0,pdi->pParmInfo,(i3+1)*sizeof(PARAMETER_INFO));

        //ByVal
        if(buffer[i]==1&&buffer[i+1]==ESC_BYVAL){
            pdi->pParmInfo[i3].bByVal=1;
            i+=2;
        }
        else if(buffer[i]==1&&buffer[i+1]==ESC_BYREF){
            pdi->pParmInfo[i3].bByVal=0;
            i+=2;
        }
        else pdi->pParmInfo[i3].bByVal=1;

        //変数名は無視（temporaryの変数名は型宣言文字判断のため）
        sw=0;
        for(i2=0;;i++,i2++){
            if(buffer[i]=='('){
                if(!sw) sw=1;

                i4=GetStringInPare(temporary+i2,buffer+i);
                i2+=i4-1;
                i+=i4-1;
                continue;
            }
            if(buffer[i]=='['){
                if(!sw) sw=1;

                i4=GetStringInBracket(temporary+i2,buffer+i);
                i2+=i4-1;
                i+=i4-1;
                continue;
            }
            if(!IsVariableChar(buffer[i])){
                temporary[i2]=0;
                break;
            }
            temporary[i2]=buffer[i];
        }
        if(lstrcmp(temporary,"...")==0) pdi->pParmInfo[i3].type=DEF_ELLIPSE;
        else{
            //型
            if(buffer[i]==1&&buffer[i+1]==ESC_AS){
                i+=2;
                for(i2=0;;i++,i2++){
                    if(!(IsVariableChar(buffer[i])||buffer[i]=='*')){
                        temporary[i2]=0;
                        break;
                    }
                    temporary[i2]=buffer[i];
                }
                pdi->pParmInfo[i3].type=GetTypeFixed(temporary,&pdi->pParmInfo[i3].u.index);
            }
            else{
                pdi->pParmInfo[i3].type=GetTypeFromSimpleName(temporary);
                SetError(-103,temporary,NowLine);
            }

            if(sw){
                //配列ポインタを引き渡すとき
                pdi->pParmInfo[i3].type=GetPtrType(pdi->pParmInfo[i3].type,pdi->pParmInfo[i3].u.index);
            }
        }

        //名前はダミー（使用しないため）
        pdi->pParmInfo[i3].name="";

        //構造体の場合はエラーチェック
        if(pdi->pParmInfo[i3].type==-1) SetError(3,temporary,NowLine);
        if(pdi->pParmInfo[i3].type==DEF_OBJECT){
            if(pdi->pParmInfo[i3].bByVal) pdi->pParmInfo[i3].type=DEF_LONG;//SetError(28,temporary,NowLine);
        }

        //構造体アドレスの空白部
        while(buffer[i]==' ') i++;

        if(buffer[i]==','){
            i++;
            continue;
        }
        else if(buffer[i]==')') continue;
        else{
            SetError(1,NULL,NowLine);
            break;
        }
    }
    pdi->ParmNum=i3;

    //戻り値
    i++;
    if(buffer[i]==1&&buffer[i+1]==ESC_AS){
        if(IsFunction==0) SetError(1,NULL,NowLine);
        i+=2;
        pdi->ReturnType=GetTypeFixed(buffer+i,&pdi->u.ReturnIndex);
        if(pdi->ReturnType==-1) SetError(3,buffer+i,NowLine);
        if(pdi->ReturnType==DEF_OBJECT) SetError(40,NULL,NowLine);
    }
    else if(buffer[i]) SetError(1,NULL,NowLine);
    else pdi->ReturnType=-1;

    pdi->pos=NowLine;
}

BOOL CompareParameter(PARAMETER_INFO *ppi1,int pi_num1,PARAMETER_INFO *ppi2,int pi_num2){
    if(pi_num1!=pi_num2) return 1;

    int i;
    for(i=0;i<pi_num1;i++){
        if(ppi1[i].type!=ppi2[i].type){

            if(ppi1[i].bByVal==0&&ppi1[i].type==DEF_ANY&&
                ppi2[i].bByVal==1&&IsPtrType(ppi2[i].type)||
                ppi1[i].bByVal==1&&IsPtrType(ppi1[i].type)&&
                ppi2[i].bByVal==0&&ppi2[i].type==DEF_ANY){
                    /* ByRef var As Any
                            と
                        var As VoidPtr
                        は同等
                    */
                    continue;
            }

            return 1;
        }
        else{
            if(NATURAL_TYPE(ppi1[i].type)==DEF_OBJECT){
                if(ppi1[i].u.index!=ppi2[i].u.index) return 1;
            }
        }
    }

    return 0;
}
SUBINFO *AddSubData(char *buffer,int NowLine,BOOL bVirtual,CClass *pobj_c,BOOL bStatic){
    int i,i2,i3,sw;
    DWORD dwType;
    char temporary[8192],temp2[VN_SIZE];

    i=1;
    if(buffer[i]==ESC_SUB) dwType=SUBTYPE_SUB;
    else if(buffer[i]==ESC_FUNCTION) dwType=SUBTYPE_FUNCTION;
    else if(buffer[i]==ESC_MACRO) dwType=SUBTYPE_MACRO;

    i++;

    BOOL bExport=0,bCdecl=0;
    while(1){
        if(buffer[i]==1&&buffer[i+1]==ESC_EXPORT&&bExport==0){
            bExport=1;

            i+=2;
        }
        else if(buffer[i]==1&&buffer[i+1]==ESC_CDECL&&bCdecl==0){
            bCdecl=1;

            i+=2;
        }
        else break;
    }

    i2=0;
    if(buffer[i]==1&&buffer[i+1]==ESC_OPERATOR){
        if(!pobj_c){
            SetError(126,NULL,NowLine);
            return 0;
        }

        //オペレータの場合
        temporary[i2++]=buffer[i++];
        temporary[i2++]=buffer[i++];

        int iCalcId;
        if(buffer[i]=='='&&buffer[i+1]=='='){
            iCalcId=CALC_EQUAL;
            i3=2;
        }
        else if(buffer[i]=='='){
            iCalcId=CALC_SUBSITUATION;
            i3=1;
        }
        else if(buffer[i]=='('){
            iCalcId=CALC_AS;
            i3=0;
        }
        else if(buffer[i]=='['&&buffer[i+1]==']'&&buffer[i+2]=='='){
            iCalcId=CALC_ARRAY_SET;
            i3=3;
        }
        else if(buffer[i]=='['&&buffer[i+1]==']'){
            iCalcId=CALC_ARRAY_GET;
            i3=2;
        }
        else{
            iCalcId=GetCalcId(buffer+i,&i3);
            i3++;
        }
        if(!iCalcId){
            SetError(1,NULL,NowLine);
            return 0;
        }
        temporary[i2++]=iCalcId;
        temporary[i2]=0;

        i+=i3;
    }
    else{
        if(pobj_c){
            //クラスメンバの場合、デストラクタには~が付くことを考慮
            if(buffer[i]=='~'){
                temporary[i2]='~';
                i++;
                i2++;
            }
        }

        for(;;i++,i2++){
            if(!IsVariableChar(buffer[i])){
                temporary[i2]=0;
                break;
            }
            temporary[i2]=buffer[i];
        }
    }

    if(dwType==SUBTYPE_MACRO){
        //大文字に変換
        CharUpper(temporary);

        //マクロ関数の場合は名前リストに追加
        extern char **ppMacroNames;
        extern int MacroNum;
        ppMacroNames=(char **)HeapReAlloc(hHeap,0,ppMacroNames,(MacroNum+1)*sizeof(char *));
        ppMacroNames[MacroNum]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
        lstrcpy(ppMacroNames[MacroNum],temporary);
        MacroNum++;
    }

    if(!pobj_c){
        //クラスメンバ以外の場合のみ
        //重複チェック

        if(GetDeclareHash(temporary)){
            SetError(15,temporary,NowLine);
            return 0;
        }
    }

    extern int SubNum;
    SubNum++;

    SUBINFO *psi;
    psi=(SUBINFO *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,sizeof(SUBINFO));

    //クラス名
    psi->pobj_ParentClass=pobj_c;

    //ID
    static int id_base=0;
    psi->id=(id_base++);

    //関数名
    psi->name=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
    lstrcpy(psi->name,temporary);

    //ソースコードの位置
    psi->address=NowLine;

    psi->bExport=bExport;
    psi->bCdecl=bCdecl;
    psi->bVirtual=bVirtual;
    if(bExport) psi->bUse=1;
    else psi->bUse=0;
    psi->bCompile=0;
    psi->bSystem=0;

    psi->dwType=dwType;


    if(psi->dwType==SUBTYPE_FUNCTION){
        ///////////////////
        // 戻り値を取得
        ///////////////////

        psi->isReturnRef = false;

        if(pobj_c){
            if(lstrcmp(psi->name,pobj_c->name)==0||
                psi->name[0]=='~'){
                //クラスのコンストラクタ、デストラクタがFunction定義の場合はエラーをだす
                SetError(115,NULL,NowLine);
            }
        }


        i2=lstrlen(buffer)-2;

        int sw_as=0;
        for(;i2>0;i2--){
            if(buffer[i2]==')') break;

            if(buffer[i2]==1&&buffer[i2+1]==ESC_AS){
                if( buffer[i2-2] == 1 && buffer[i2-1] == ESC_BYREF ){
                    //参照型
                    psi->isReturnRef = true;
                }

                i2+=2;
                i3=0;
                while(buffer[i2]=='*') temporary[i3++]=buffer[i2++];
                for(;;i2++,i3++){
                    if(!IsVariableChar(buffer[i2])){
                        temporary[i3]=0;
                        break;
                    }
                    temporary[i3]=buffer[i2];
                }
                psi->ReturnType=GetTypeFixed(temporary,&psi->u.ReturnIndex);
                if(psi->ReturnType==-1) SetError(3,temporary,NowLine);

                sw_as=1;
                break;
            }
        }

        if(!sw_as){
            SetError(-104,psi->name,NowLine);

            psi->ReturnType=DEF_DOUBLE;
        }
    }
    else{
        //戻り値なしのSub定義
        psi->ReturnType=-1;
        psi->u.ReturnIndex=-1;
    }



    psi->pParmInfo=(PARAMETER_INFO *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,sizeof(PARAMETER_INFO)*2);
    psi->ParmNum=0;

    //パラメータ
    if(buffer[i]!='('){
        SetError(1,NULL,NowLine);
        return 0;
    }
    i++;
    if(buffer[i]!=')'&&pobj_c){
        //クラスのメンバ関数の場合のみ、デストラクタにパラメータがある場合にエラーをだす
        if(psi->name[0]=='~'){
            SetError(114,NULL,NowLine);
            i=JumpStringInPare(buffer,i);
        }
    }
    while(1){
        if(buffer[i]==')') break;

        psi->pParmInfo=(PARAMETER_INFO *)HeapReAlloc(hHeap,0,psi->pParmInfo,(psi->ParmNum+1)*sizeof(PARAMETER_INFO));

        //ByVal
        if(buffer[i]==1&&buffer[i+1]==ESC_BYVAL){
            psi->pParmInfo[psi->ParmNum].bByVal=1;
            i+=2;
        }
        else if(buffer[i]==1&&buffer[i+1]==ESC_BYREF){
            psi->pParmInfo[psi->ParmNum].bByVal=0;
            i+=2;
        }
        else psi->pParmInfo[psi->ParmNum].bByVal=1;

        //パラメータ名
        sw=0;
        for(i2=0;;i++,i2++){
            if(buffer[i]=='('){
                if(!sw) sw=1;

                i3=GetStringInPare(temporary+i2,buffer+i);
                i2+=i3-1;
                i+=i3-1;
                continue;
            }
            if(buffer[i]=='['){
                if(!sw) sw=1;

                i3=GetStringInBracket(temporary+i2,buffer+i);
                i2+=i3-1;
                i+=i3-1;
                continue;
            }
            if(!IsVariableChar(buffer[i])){
                temporary[i2]=0;
                break;
            }
            temporary[i2]=buffer[i];
        }
        if(sw){
            //配列パラメータ
            if(psi->pParmInfo[psi->ParmNum].bByVal) SetError(29,NULL,NowLine);
            psi->pParmInfo[psi->ParmNum].bArray=1;

            if((temporary[i2-2]=='('&&temporary[i2-1]==')')||
                (temporary[i2-2]=='['&&temporary[i2-1]==']')){
                psi->pParmInfo[psi->ParmNum].SubScripts[0]=LONG_MAX;
                psi->pParmInfo[psi->ParmNum].SubScripts[1]=-1;

                temporary[i2-2]=0;
            }
            else{
                GetArrange(temporary,temp2,psi->pParmInfo[psi->ParmNum].SubScripts);
                lstrcpy(temporary,temp2);
            }

            i2=lstrlen(temporary);
        }
        else{
            psi->pParmInfo[psi->ParmNum].bArray=0;
            psi->pParmInfo[psi->ParmNum].SubScripts[0]=-1;
        }
        psi->pParmInfo[psi->ParmNum].name=(char *)HeapAlloc(hHeap,0,i2+1);
        lstrcpy(psi->pParmInfo[psi->ParmNum].name,temporary);

        //型
        if(buffer[i]==1&&buffer[i+1]==ESC_AS){
            i+=2;

            i2=0;
            while(buffer[i]=='*'){
                temporary[i2]=buffer[i];
                i++;
                i2++;
            }
            for(;;i++,i2++){
                if(!IsVariableChar(buffer[i])){
                    if(buffer[i]==1&&(buffer[i+1]==ESC_FUNCTION||buffer[i+1]==ESC_SUB)){
                        temporary[i2++]=buffer[i++];
                        temporary[i2]=buffer[i];
                        continue;
                    }
                    temporary[i2]=0;
                    break;
                }
                temporary[i2]=buffer[i];
            }

            psi->pParmInfo[psi->ParmNum].type=
                GetTypeFixed(temporary,&psi->pParmInfo[psi->ParmNum].u.index);

            if(temporary[0]=='*'&&
                temporary[1]==1&&
                (temporary[2]==ESC_FUNCTION||temporary[2]==ESC_SUB)){
                if(buffer[i]!='('){
                    SetError(10,temporary,NowLine);
                    return 0;
                }
                i3=GetStringInPare(temporary+i2,buffer+i);
                i+=i3;
                i2+=i3;

                if(temporary[2]==ESC_FUNCTION&&buffer[i]==1&&buffer[i+1]==ESC_AS){
                    temporary[i2++]=buffer[i++];
                    temporary[i2++]=buffer[i++];
                    for(;;i++,i2++){
                        if(!IsVariableChar(buffer[i])){
                            temporary[i2]=0;
                            break;
                        }
                        temporary[i2]=buffer[i];
                    }
                }
            }
            else{
                //TypeDefをする前のベース型を取得
                GetOriginalTypeName(temporary);
            }

            if(psi->pParmInfo[psi->ParmNum].type==-1){
                SetError(3,temporary,NowLine);
                psi->pParmInfo[psi->ParmNum].type=DEF_PTR_VOID;
            }

            /*未完成（構造体パラメータを値参照として渡してよいものか！？）
            if(psi->pParmInfo[psi->ParmNum].type==DEF_OBJECT){
                if(psi->pParmInfo[psi->ParmNum].bByVal) SetError(28,temporary,NowLine);
            }*/
        }
        else{
            psi->pParmInfo[psi->ParmNum].type=GetTypeFromSimpleName(temporary);
            SetError(-103,temporary,NowLine);
        }

        if(psi->pParmInfo[psi->ParmNum].type==DEF_PTR_PROC){
            //関数ポインタの場合
            psi->pParmInfo[psi->ParmNum].u.index=AddProcPtrInfo(temporary+3,temporary[2]);
        }

        //パラメータの数を更新
        psi->ParmNum++;

        if(buffer[i]==','){
            i++;
            continue;
        }
        else if(buffer[i]==')') continue;
        else{
            SetError(1,NULL,NowLine);
            return 0;
        }
    }
    psi->SecondParmNum=psi->ParmNum;
    i++;
    if(buffer[i]=='('){
        i++;
        while(1){
            if(buffer[i]==')') break;

            psi->pParmInfo=(PARAMETER_INFO *)HeapReAlloc(hHeap,0,psi->pParmInfo,(psi->ParmNum+1)*sizeof(PARAMETER_INFO));

            //ByVal
            if(buffer[i]==1&&buffer[i+1]==ESC_BYVAL){
                psi->pParmInfo[psi->ParmNum].bByVal=1;
                i+=2;
            }
            else if(buffer[i]==1&&buffer[i+1]==ESC_BYREF){
                psi->pParmInfo[psi->ParmNum].bByVal=0;
                i+=2;
            }
            else psi->pParmInfo[psi->ParmNum].bByVal=1;

            //パラメータ名
            sw=0;
            for(i2=0;;i++,i2++){
                if(buffer[i]=='('){
                    if(!sw) sw=1;

                    i3=GetStringInPare(temporary+i2,buffer+i);
                    i2+=i3-1;
                    i+=i3-1;
                    continue;
                }
                if(buffer[i]=='['){
                    if(!sw) sw=1;

                    i3=GetStringInBracket(temporary+i2,buffer+i);
                    i2+=i3-1;
                    i+=i3-1;
                    continue;
                }
                if(!IsVariableChar(buffer[i])){
                    temporary[i2]=0;
                    break;
                }
                temporary[i2]=buffer[i];
            }
            if(sw){
                //配列パラメータ
                if(psi->pParmInfo[psi->ParmNum].bByVal) SetError(29,NULL,NowLine);
                psi->pParmInfo[psi->ParmNum].bArray=1;

                if((temporary[i2-2]=='('&&temporary[i2-1]==')')||
                    (temporary[i2-2]=='['&&temporary[i2-1]==']')){
                    psi->pParmInfo[psi->ParmNum].SubScripts[0]=LONG_MAX;
                    psi->pParmInfo[psi->ParmNum].SubScripts[1]=-1;

                    temporary[i2-2]=0;
                }
                else{
                    GetArrange(temporary,temp2,psi->pParmInfo[psi->ParmNum].SubScripts);
                    lstrcpy(temporary,temp2);
                }

                i2=lstrlen(temporary);
            }
            else{
                psi->pParmInfo[psi->ParmNum].bArray=0;
                psi->pParmInfo[psi->ParmNum].SubScripts[0]=-1;
            }
            psi->pParmInfo[psi->ParmNum].name=(char *)HeapAlloc(hHeap,0,i2+1);
            lstrcpy(psi->pParmInfo[psi->ParmNum].name,temporary);

            //型
            if(buffer[i]==1&&buffer[i+1]==ESC_AS){
                i+=2;
                i2=0;
                while(buffer[i]=='*'){
                    temporary[i2]=buffer[i];
                    i++;
                    i2++;
                }
                for(;;i++,i2++){
                    if(!IsVariableChar(buffer[i])){
                        temporary[i2]=0;
                        break;
                    }
                    temporary[i2]=buffer[i];
                }
                psi->pParmInfo[psi->ParmNum].type=
                    GetTypeFixed(temporary,&psi->pParmInfo[psi->ParmNum].u.index);
                if(psi->pParmInfo[psi->ParmNum].type==-1) SetError(3,temporary,NowLine);
            }
            else{
                psi->pParmInfo[psi->ParmNum].type=GetTypeFromSimpleName(temporary);
                SetError(-103,temporary,NowLine);
            }

            psi->ParmNum++;

            if(buffer[i]==','){
                i++;
                continue;
            }
            else if(buffer[i]==')') continue;
            else{
                SetError(1,NULL,NowLine);
                return 0;
            }
        }
        i++;
    }

    //リアルパラメータ領域を取得（_System_LocalThis、_System_ReturnValueを考慮して2つだけ多く確保する）
    psi->pRealParmInfo=(PARAMETER_INFO *)HeapAlloc(hHeap,0,(psi->ParmNum+2)*sizeof(PARAMETER_INFO));
    psi->RealParmNum=0;

    if(pobj_c&&bStatic==0){
        i = psi->RealParmNum;

        //オブジェクトメンバの場合は、第一パラメータを_System_LocalThis引き渡し用として利用
        psi->pRealParmInfo[i].name = "_System_LocalThis";
        psi->pRealParmInfo[i].type=DEF_PTR_VOID;
        psi->pRealParmInfo[i].u.index=-1;
        psi->pRealParmInfo[i].bByVal=1;
        psi->pRealParmInfo[i].bArray=0;
        psi->pRealParmInfo[i].SubScripts[0]=-1;

        psi->RealParmNum++;
    }

    if(psi->ReturnType==DEF_OBJECT && psi->isReturnRef == false){
        i = psi->RealParmNum;

        //実体オブジェクトを戻り値として持つ場合
        //※第一パラメータ（Thisポインタありの場合は第二パラメータ）を戻り値用の参照宣言にする

        if(psi->name[0]==1&&psi->name[1]==ESC_OPERATOR)
            psi->pRealParmInfo[i].name="_System_ReturnValue";
        else psi->pRealParmInfo[i].name=psi->name;
        psi->pRealParmInfo[i].type=DEF_OBJECT;
        psi->pRealParmInfo[i].u.index=psi->u.ReturnIndex;
        psi->pRealParmInfo[i].bByVal=0;
        psi->pRealParmInfo[i].bArray=0;
        psi->pRealParmInfo[i].SubScripts[0]=-1;
        
        psi->RealParmNum++;
    }

    //パラメータをコピー
    for( i = 0; i < psi->ParmNum; i++, psi->RealParmNum++ ){
        psi->pRealParmInfo[psi->RealParmNum]=psi->pParmInfo[i];
    }


    /////////////////////////////////
    // ハッシュデータに追加
    /////////////////////////////////

    int key;
    key=hash_default(psi->name);

    extern SUBINFO **ppSubHash;
    if(ppSubHash[key]){
        SUBINFO *psi2;
        psi2=ppSubHash[key];
        while(1){
            if(pobj_c==psi2->pobj_ParentClass){
                //重複エラーチェックを行う
                if(lstrcmp(psi2->name,psi->name)==0){
                    if(CompareParameter(psi2->pParmInfo,psi2->ParmNum,psi->pParmInfo,psi->ParmNum)==0){
                        SetError(15,psi->name,NowLine);
                        return 0;
                    }
                }
            }

            if(psi2->pNextData==0) break;
            psi2=psi2->pNextData;
        }
        psi2->pNextData=psi;
    }
    else{
        ppSubHash[key]=psi;
    }

    return psi;
}

void GetSubInfo(void){  //サブルーチン情報を取得
    extern HANDLE hHeap;
    extern char *basbuf;
    int i,i2,i3;
    char temporary[8192];

    //Declare（DLL関数）情報を初期化
    extern DECLAREINFO **ppDeclareHash;
    ppDeclareHash=(DECLAREINFO **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(DECLAREINFO *));

    //サブルーチン（ユーザー定義）情報を初期化
    extern SUBINFO **ppSubHash;
    extern int SubNum;
    ppSubHash=(SUBINFO **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(SUBINFO *));
    SubNum=0;

    //マクロ関数の名前リストを初期化
    extern char **ppMacroNames;
    extern int MacroNum;
    ppMacroNames=(char **)HeapAlloc(hHeap,0,1);
    MacroNum=0;

    i=-1;
    while(1){
        i++;

        if(basbuf[i]==1&&(basbuf[i+1]==ESC_CLASS||basbuf[i+1]==ESC_INTERFACE)){
            /*  Class ～ End Class
                Interface ～ End Interface
                を飛び越す           */
            i3=GetEndXXXCommand(basbuf[i+1]);
            for(i+=2,i2=0;;i++,i2++){
                if(basbuf[i]=='\0') break;
                if(basbuf[i]==1&&basbuf[i+1]==(char)i3){
                    i++;
                    break;
                }
            }
            if(basbuf[i]=='\0') break;
            continue;
        }

        if(basbuf[i]==1&&basbuf[i+1]==ESC_DECLARE){
            for(i+=2,i2=0;;i2++,i++){
                if(basbuf[i]=='\n'){
                    temporary[i2]=0;
                    break;
                }
                temporary[i2]=basbuf[i];
                if(basbuf[i]=='\0') break;
            }
            AddDeclareData(temporary,i);

            continue;
        }
        if(basbuf[i]==1&&(basbuf[i+1]==ESC_SUB||basbuf[i+1]==ESC_FUNCTION||basbuf[i+1]==ESC_MACRO)){
            for(i2=0;;i2++,i++){
                if(IsCommandDelimitation(basbuf[i])){
                    temporary[i2]=0;
                    break;
                }
                temporary[i2]=basbuf[i];
                if(basbuf[i]=='\0') break;
            }
            AddSubData(temporary,i,0,0);

            continue;
        }

        //次の行
        for(;;i++){
            if(IsCommandDelimitation(basbuf[i])) break;
        }
        if(basbuf[i]=='\0') break;
    }

    ////////////
    // 特殊関数
    ////////////

    sprintf(temporary,"%c%c_allrem()",1,ESC_SUB);
    AddSubData(temporary,0,0,0);

    sprintf(temporary,"%c%c_aullrem()",1,ESC_SUB);
    AddSubData(temporary,0,0,0);

    sprintf(temporary,"%c%c_allmul()",1,ESC_SUB);
    AddSubData(temporary,0,0,0);

    sprintf(temporary,"%c%c_alldiv()",1,ESC_SUB);
    AddSubData(temporary,0,0,0);

    sprintf(temporary,"%c%c_aulldiv()",1,ESC_SUB);
    AddSubData(temporary,0,0,0);

    sprintf(temporary,"%c%c_allshl()",1,ESC_SUB);
    AddSubData(temporary,0,0,0);

    sprintf(temporary,"%c%c_allshr()",1,ESC_SUB);
    AddSubData(temporary,0,0,0);

    sprintf(temporary,"%c%c_aullshr()",1,ESC_SUB);
    AddSubData(temporary,0,0,0);

    sprintf(temporary,"%c%c_System_InitStaticLocalVariables()",1,ESC_SUB);
    AddSubData(temporary,0,0,0);
}
void Delete_si(SUBINFO *psi){
    int i2;

    for(i2=0;i2<psi->ParmNum;i2++){
        HeapDefaultFree(psi->pParmInfo[i2].name);
    }
    HeapDefaultFree(psi->pRealParmInfo);
    if(psi->pParmInfo) HeapDefaultFree(psi->pParmInfo);
    psi->pRealParmInfo=0;
    psi->pParmInfo=0;

    if(psi->pNextData) Delete_si(psi->pNextData);

    HeapDefaultFree(psi->name);
    HeapDefaultFree(psi);
}
void DeleteSubInfo(SUBINFO **ppSubHash,char **ppMacroNames,int MacroNum){   //サブルーチン情報のメモリ解放
    int i;
    for(i=0;i<MAX_HASH;i++){
        if(!ppSubHash[i]) continue;

        Delete_si(ppSubHash[i]);
    }
    HeapDefaultFree(ppSubHash);

    //マクロの名前リスト
    if(ppMacroNames){
        for(i=0;i<MacroNum;i++){
            HeapDefaultFree(ppMacroNames[i]);
        }
        HeapDefaultFree(ppMacroNames);
    }
}
void Delete_di(DECLAREINFO *pdi){
    if(pdi->pParmInfo) HeapDefaultFree(pdi->pParmInfo);

    HeapDefaultFree(pdi->name);
    if(pdi->file) HeapDefaultFree(pdi->file);
    if(pdi->alias) HeapDefaultFree(pdi->alias);

    if(pdi->pNextData) Delete_di(pdi->pNextData);

    HeapDefaultFree(pdi);
}
void DeleteDeclareInfo(void){
    //DLL情報を解放
    extern DECLAREINFO **ppDeclareHash;
    int i;
    for(i=0;i<MAX_HASH;i++){
        if(!ppDeclareHash[i]) continue;

        Delete_di(ppDeclareHash[i]);
    }
    HeapDefaultFree(ppDeclareHash);
}



///////////////////////
// 関数ポインタの管理
///////////////////////

int AddProcPtrInfo(char *buffer,DWORD dwProcType){
    extern HANDLE hHeap;
    extern int cp;
    extern PROCPTRINFO *pProcPtrInfo;
    extern int ProcPtrInfoNum;
    int i,i2,i3,sw;
    PROCPTRINFO *pi;
    char temporary[VN_SIZE],temp2[VN_SIZE];

    pProcPtrInfo=(PROCPTRINFO *)HeapReAlloc(hHeap,0,pProcPtrInfo,(ProcPtrInfoNum+1)*sizeof(PROCPTRINFO));
    pi=&pProcPtrInfo[ProcPtrInfoNum];
    ProcPtrInfoNum++;

    pi->pParmInfo=(PARAMETER_INFO *)HeapAlloc(hHeap,0,1);
    pi->ParmNum=0;

    //buffer[0]は'('となっている
    i=1;

    while(1){
        if(buffer[i]==')') break;

        pi->pParmInfo=(PARAMETER_INFO *)HeapReAlloc(hHeap,0,pi->pParmInfo,(pi->ParmNum+1)*sizeof(PARAMETER_INFO));

        //ByVal
        if(buffer[i]==1&&buffer[i+1]==ESC_BYVAL){
            pi->pParmInfo[pi->ParmNum].bByVal=1;
            i+=2;
        }
        else if(buffer[i]==1&&buffer[i+1]==ESC_BYREF){
            pi->pParmInfo[pi->ParmNum].bByVal=0;
            i+=2;
        }
        else pi->pParmInfo[pi->ParmNum].bByVal=1;

        //パラメータ名
        sw=0;
        for(i2=0;;i++,i2++){
            if(buffer[i]=='('){
                if(!sw) sw=1;

                i3=GetStringInPare(temporary+i2,buffer+i);
                i2+=i3-1;
                i+=i3-1;
                continue;
            }
            if(buffer[i]=='['){
                if(!sw) sw=1;

                i3=GetStringInBracket(temporary+i2,buffer+i);
                i2+=i3-1;
                i+=i3-1;
                continue;
            }
            if(!IsVariableChar(buffer[i])){
                temporary[i2]=0;
                break;
            }
            temporary[i2]=buffer[i];
        }
        pi->pParmInfo[pi->ParmNum].name=0;

        if(sw){
            //配列パラメータ
            if(pi->pParmInfo[pi->ParmNum].bByVal) SetError(29,NULL,cp);
            pi->pParmInfo[pi->ParmNum].bArray=1;

            if((temporary[i2-2]=='('&&temporary[i2-1]==')')||
                (temporary[i2-2]=='['&&temporary[i2-1]==']')){
                pi->pParmInfo[pi->ParmNum].SubScripts[0]=LONG_MAX;
                pi->pParmInfo[pi->ParmNum].SubScripts[1]=-1;

                temporary[i2-2]=0;
            }
            else{
                GetArrange(temporary,temp2,pi->pParmInfo[pi->ParmNum].SubScripts);
                lstrcpy(temporary,temp2);
            }

            i2=lstrlen(temporary);
        }
        else{
            pi->pParmInfo[pi->ParmNum].bArray=0;
            pi->pParmInfo[pi->ParmNum].SubScripts[0]=-1;
        }

        //型
        if(buffer[i]==1&&buffer[i+1]==ESC_AS){
            i+=2;

            i2=0;
            while(buffer[i]=='*'){
                temporary[i2]=buffer[i];
                i++;
                i2++;
            }
            for(;;i++,i2++){
                if(!IsVariableChar(buffer[i])){
                    temporary[i2]=0;
                    break;
                }
                temporary[i2]=buffer[i];
            }

            pi->pParmInfo[pi->ParmNum].type=
                GetTypeFixed(temporary,&pi->pParmInfo[pi->ParmNum].u.index);
            if(pi->pParmInfo[pi->ParmNum].type==-1){
                SetError(3,temporary,cp);
                pi->pParmInfo[pi->ParmNum].type=DEF_PTR_VOID;
            }
            if(pi->pParmInfo[pi->ParmNum].type==DEF_OBJECT){
                if(pi->pParmInfo[pi->ParmNum].bByVal) SetError(28,temporary,cp);
            }
        }
        else{
            pi->pParmInfo[pi->ParmNum].type=GetTypeFromSimpleName(temporary);
            SetError(-103,temporary,cp);
        }

        pi->ParmNum++;

        if(buffer[i]==','){
            i++;
            continue;
        }
        else if(buffer[i]==')') continue;
        else{
            SetError(1,NULL,cp);
            return 0;
        }
    }
    i++;

    //戻り値
    if(dwProcType==ESC_FUNCTION){
        if(buffer[i]==1&&buffer[i+1]==ESC_AS){
            i+=2;
            i2=0;
            if(buffer[i]=='*') temporary[i2++]=buffer[i++];
            for(;;i++,i2++){
                if(!IsVariableChar(buffer[i])){
                    temporary[i2]=0;
                    break;
                }
                temporary[i2]=buffer[i];
            }
            pi->ReturnType=GetTypeFixed(temporary,&pi->u.ReturnIndex);
            if(pi->ReturnType==-1) SetError(3,temporary,cp);
            if(pi->ReturnType==DEF_OBJECT) SetError(40,NULL,cp);
        }
        else pi->ReturnType=DEF_DOUBLE;
    }
    else pi->ReturnType=-1;

    return ProcPtrInfoNum-1;
}
void DeleteProcPtrInfo(void){
    extern PROCPTRINFO *pProcPtrInfo;
    extern int ProcPtrInfoNum;
    int i;

    for(i=0;i<ProcPtrInfoNum;i++){
        HeapDefaultFree(pProcPtrInfo[i].pParmInfo);
    }

    HeapDefaultFree(pProcPtrInfo);
}