Changeset 209 in dev


Ignore:
Timestamp:
Jul 13, 2007, 4:22:02 AM (17 years ago)
Author:
dai_9181
Message:

DllProcsクラスを追加。

Location:
trunk/abdev
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/abdev/BasicCompiler32/MakePeHdr.cpp

    r208 r209  
    181181
    182182    //クラス名を取得（詳細情報はGetAllClassInfoで取得）
    183     //   CollectUserProcs関数の中で参照されるオブジェクト名を事前に取得する。
     183    //   CollectProcedures関数の中で参照されるオブジェクト名を事前に取得する。
    184184    //     ※オブジェクトの内容までは取得しない
    185185    compiler.GetMeta().GetClasses().CollectClassesForNameOnly( Smoothie::Lexical::source );
    … …  
    192192
    193193    // サブルーチン（ユーザー定義、DLL関数）の識別子、アドレスを取得
    194     compiler.pCompilingClass=0;
    195     UserProcs::CollectUserProcs( Smoothie::Lexical::source, compiler.GetMeta().GetUserProcs() );
    196 
    197     // クラス情報を取得（※注 - CollectUserProcsの後に呼び出す）
     194    compiler.pCompilingClass = NULL;
     195    CollectProcedures(
     196        Smoothie::Lexical::source,
     197        compiler.GetMeta().GetUserProcs(),
     198        compiler.GetMeta().GetDllProcs()
     199    );
     200
     201    // クラス情報を取得（※注 - CollectProceduresの後に呼び出す）
    198202    compiler.GetMeta().GetClasses().GetAllClassInfo();
    199203
    200204    // サブルーチン（ユーザー定義、DLL関数）のイテレータの準備
    201205    compiler.GetMeta().GetUserProcs().Iterator_Init();
     206    compiler.GetMeta().GetDllProcs().Iterator_Init();
     207
    202208/*
    203209    if( !compiler.GetMeta().Write( Jenga::Common::Environment::GetAppDir() + "\\meta_test.xml" ) )
    … …  
    533539    // 使用するDLL関数のチェック
    534540    ////////////////////////////////
    535     for(i=0;i<MAX_HASH;i++){
    536         extern DllProc **ppDeclareHash;
    537         const DllProc *pDllProc = ppDeclareHash[i];
    538         while(pDllProc){
    539             if( !pDllProc->IsUsing() ){
    540                 pDllProc=pDllProc->pNextData;
    541                 continue;
     541    compiler.GetMeta().GetDllProcs().Iterator_Reset();
     542    while( compiler.GetMeta().GetDllProcs().Iterator_HasNext() )
     543    {
     544        const DllProc *pDllProc = compiler.GetMeta().GetDllProcs().Iterator_GetNext();
     545
     546        if( !pDllProc->IsUsing() ){
     547            pDllProc=pDllProc->pNextData;
     548            continue;
     549        }
     550
     551        //エラーチェック
     552        HINSTANCE hLib;
     553        hLib=LoadLibrary( pDllProc->GetDllFileName().c_str() );
     554        if(!hLib){
     555            extern char OutputFileName[MAX_PATH];
     556            char temp2[MAX_PATH],temp3[MAX_PATH];
     557            _splitpath(OutputFileName,temp2,temp3,NULL,NULL);
     558            lstrcat(temp2,temp3);
     559            lstrcpy(temp3,pDllProc->GetDllFileName().c_str());
     560            GetFullPath(temp3,temp2);
     561            hLib=LoadLibrary(temp3);
     562
     563            if(!hLib){
     564                SetError(-106,pDllProc->GetDllFileName().c_str(),pDllProc->GetCodePos());
    542565            }
    543 
    544             //エラーチェック
    545             HINSTANCE hLib;
    546             hLib=LoadLibrary( pDllProc->GetDllFileName().c_str() );
    547             if(!hLib){
    548                 extern char OutputFileName[MAX_PATH];
    549                 char temp2[MAX_PATH],temp3[MAX_PATH];
    550                 _splitpath(OutputFileName,temp2,temp3,NULL,NULL);
    551                 lstrcat(temp2,temp3);
    552                 lstrcpy(temp3,pDllProc->GetDllFileName().c_str());
    553                 GetFullPath(temp3,temp2);
    554                 hLib=LoadLibrary(temp3);
    555 
    556                 if(!hLib){
    557                     SetError(-106,pDllProc->GetDllFileName().c_str(),pDllProc->GetCodePos());
    558                 }
     566        }
     567
     568        if(hLib){
     569            if(!GetProcAddress(hLib,pDllProc->GetAlias().c_str())){
     570                FreeLibrary(hLib);
     571                SetError(-107,pDllProc->GetAlias(),pDllProc->GetCodePos());
    559572            }
    560 
    561             if(hLib){
    562                 if(!GetProcAddress(hLib,pDllProc->GetAlias().c_str())){
    563                     FreeLibrary(hLib);
    564                     SetError(-107,pDllProc->GetAlias(),pDllProc->GetCodePos());
    565                 }
    566                 FreeLibrary(hLib);
    567             }
    568 
    569             pDllProc=pDllProc->pNextData;
     573            FreeLibrary(hLib);
    570574        }
    571575    }
    … …  
    679683    //インポートDLL情報
    680684    /////////////////////
    681     extern DllProc **ppDeclareHash;
    682     char **ppDllNames;
    683     int ImportDllNum;
    684685
    685686    /*
    … …  
    697698    */
    698699
    699     ppDllNames=(char **)HeapAlloc(hHeap,0,1);
    700 
    701     ImportDllNum=0;
    702     for(i=0;i<MAX_HASH;i++){
    703         const DllProc *pDllProc=ppDeclareHash[i];
    704         while(pDllProc){
    705             if( !pDllProc->IsUsing() ){
    706                 pDllProc=pDllProc->pNextData;
    707                 continue;
    708             }
    709 
    710             if( pDllProc->GetDllFileName().size() > 16 ){
    711                 SetError(7,NULL,cp);
     700    char **ppDllNames=(char **)HeapAlloc(hHeap,0,1);
     701
     702    int ImportDllNum=0;
     703
     704    compiler.GetMeta().GetDllProcs().Iterator_Reset();
     705    while( compiler.GetMeta().GetDllProcs().Iterator_HasNext() )
     706    {
     707        const DllProc *pDllProc = compiler.GetMeta().GetDllProcs().Iterator_GetNext();
     708
     709        if( !pDllProc->IsUsing() ){
     710            pDllProc=pDllProc->pNextData;
     711            continue;
     712        }
     713
     714        if( pDllProc->GetDllFileName().size() > 16 ){
     715            SetError(7,NULL,cp);
     716            break;
     717        }
     718        for(i2=0;i2<ImportDllNum;i2++){
     719            if( pDllProc->GetDllFileName() == ppDllNames[i2] ){
    712720                break;
    713721            }
    714             for(i2=0;i2<ImportDllNum;i2++){
    715                 if( pDllProc->GetDllFileName() == ppDllNames[i2] ){
    716                     break;
    717                 }
    718             }
    719             if(i2==ImportDllNum){
    720                 ppDllNames=(char **)HeapReAlloc(hHeap,0,ppDllNames,(ImportDllNum+1)*sizeof(char **));
    721                 ppDllNames[ImportDllNum]=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,16);
    722                 lstrcpy(ppDllNames[ImportDllNum],pDllProc->GetDllFileName().c_str());
    723                 ImportDllNum++;
    724             }
    725 
    726             pDllProc=pDllProc->pNextData;
     722        }
     723        if(i2==ImportDllNum){
     724            ppDllNames=(char **)HeapReAlloc(hHeap,0,ppDllNames,(ImportDllNum+1)*sizeof(char **));
     725            ppDllNames[ImportDllNum]=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,16);
     726            lstrcpy(ppDllNames[ImportDllNum],pDllProc->GetDllFileName().c_str());
     727            ImportDllNum++;
    727728        }
    728729    }
    … …  
    740741        pImportTable[i].ForwarderChain=0;
    741742        pImportTable[i].Name=i3+i*0x10;
    742         for(i2=0;i2<MAX_HASH;i2++){
    743             const DllProc *pDllProc=ppDeclareHash[i2];
    744             while(pDllProc){
    745                 if( !pDllProc->IsUsing() ){
    746                     pDllProc=pDllProc->pNextData;
    747                     continue;
    748                 }
    749 
    750                 if( pDllProc->GetDllFileName() == ppDllNames[i] ){
    751                     //ルックアップデータのサイズを追加
    752                     LookupSize+=sizeof(DWORD);
    753                 }
    754 
     743
     744        compiler.GetMeta().GetDllProcs().Iterator_Reset();
     745        while( compiler.GetMeta().GetDllProcs().Iterator_HasNext() )
     746        {
     747            const DllProc *pDllProc = compiler.GetMeta().GetDllProcs().Iterator_GetNext();
     748
     749            if( !pDllProc->IsUsing() ){
    755750                pDllProc=pDllProc->pNextData;
     751                continue;
     752            }
     753
     754            if( pDllProc->GetDllFileName() == ppDllNames[i] ){
     755                //ルックアップデータのサイズを追加
     756                LookupSize+=sizeof(DWORD);
    756757            }
    757758        }
    … …  
    770771    i3+=ImportDllNum*0x10;
    771772    for(i=0,i5=0;i<ImportDllNum;i++){
    772         for(i2=0;i2<MAX_HASH;i2++){
    773             DllProc *pDllProc=ppDeclareHash[i2];
    774             while(pDllProc){
    775                 if( !pDllProc->IsUsing() ){
    776                     pDllProc=pDllProc->pNextData;
    777                     continue;
     773        compiler.GetMeta().GetDllProcs().Iterator_Reset();
     774        while( compiler.GetMeta().GetDllProcs().Iterator_HasNext() )
     775        {
     776            DllProc *pDllProc = compiler.GetMeta().GetDllProcs().Iterator_GetNext();
     777
     778            if( !pDllProc->IsUsing() ){
     779                pDllProc=pDllProc->pNextData;
     780                continue;
     781            }
     782
     783            if( pDllProc->GetDllFileName() == ppDllNames[i] ){
     784                //ルックアップの位置をセット（後にインポート アドレス テーブルにセットしなおされる）
     785                pDllProc->SetLookupAddress( i3+(i5*sizeof(DWORD)) );
     786
     787                //ルックアップ テーブル
     788                pLookupTable[i5++]=i3+LookupSize+HintSize;
     789
     790                //ヒント テーブル
     791                pHintTable[HintSize++]=0;
     792                pHintTable[HintSize++]=0;
     793                lstrcpy(pHintTable+HintSize,pDllProc->GetAlias().c_str());
     794                i4=(int)pDllProc->GetAlias().size();
     795                HintSize+=i4+1;
     796                if(i4%2==0) pHintTable[HintSize++]=0;
     797
     798                if(HintAllocSize<HintSize+128){
     799                    HintAllocSize+=128;
     800                    pHintTable=(char *)HeapReAlloc(hHeap,0,pHintTable,HintAllocSize);
    778801                }
    779 
    780                 if( pDllProc->GetDllFileName() == ppDllNames[i] ){
    781                     //ルックアップの位置をセット（後にインポート アドレス テーブルにセットしなおされる）
    782                     pDllProc->SetLookupAddress( i3+(i5*sizeof(DWORD)) );
    783 
    784                     //ルックアップ テーブル
    785                     pLookupTable[i5++]=i3+LookupSize+HintSize;
    786 
    787                     //ヒント テーブル
    788                     pHintTable[HintSize++]=0;
    789                     pHintTable[HintSize++]=0;
    790                     lstrcpy(pHintTable+HintSize,pDllProc->GetAlias().c_str());
    791                     i4=(int)pDllProc->GetAlias().size();
    792                     HintSize+=i4+1;
    793                     if(i4%2==0) pHintTable[HintSize++]=0;
    794 
    795                     if(HintAllocSize<HintSize+128){
    796                         HintAllocSize+=128;
    797                         pHintTable=(char *)HeapReAlloc(hHeap,0,pHintTable,HintAllocSize);
    798                     }
    799                 }
    800 
    801                 pDllProc=pDllProc->pNextData;
    802802            }
    803803        }
    … …  
    10691069            HintSize;           //ヒント名（関数名）テーブル
    10701070
    1071         for(i2=0;i2<MAX_HASH;i2++){
    1072             const DllProc *pDllProc=ppDeclareHash[i2];
    1073             while(pDllProc){
    1074                 if( !pDllProc->IsUsing() ){
    1075                     pDllProc=pDllProc->pNextData;
    1076                     continue;
    1077                 }
    1078 
    1079                 if( pDllProc->GetDllFileName() == ppDllNames[i] ){
    1080                     //ルックアップ テーブル
    1081                     pLookupTable[i5++]+=MemPos_ImportSection;
    1082                 }
    1083 
     1071        compiler.GetMeta().GetDllProcs().Iterator_Reset();
     1072        while( compiler.GetMeta().GetDllProcs().Iterator_HasNext() )
     1073        {
     1074            const DllProc *pDllProc = compiler.GetMeta().GetDllProcs().Iterator_GetNext();
     1075
     1076            if( !pDllProc->IsUsing() ){
    10841077                pDllProc=pDllProc->pNextData;
     1078                continue;
     1079            }
     1080
     1081            if( pDllProc->GetDllFileName() == ppDllNames[i] ){
     1082                //ルックアップ テーブル
     1083                pLookupTable[i5++]+=MemPos_ImportSection;
    10851084            }
    10861085        }

  • trunk/abdev/BasicCompiler64/MakePeHdr.cpp

    r206 r209  
    165165
    166166    //クラス名を取得（詳細情報はGetAllClassInfoで取得）
    167     //   CollectUserProcs関数の中で参照されるオブジェクト名を事前に取得する。
     167    //   CollectProcedures関数の中で参照されるオブジェクト名を事前に取得する。
    168168    //     ※オブジェクトの内容までは取得しない
    169169    compiler.GetMeta().GetClasses().CollectClassesForNameOnly( Smoothie::Lexical::source );
    … …  
    177177    //サブルーチン（ユーザー定義、DLL関数）の識別子、アドレスを取得
    178178    compiler.pCompilingClass = NULL;
    179     UserProcs::CollectUserProcs( Smoothie::Lexical::source, compiler.GetMeta().GetUserProcs() );
    180 
    181     // クラス情報を取得（※注 - CollectUserProcsの後に呼び出す）
     179    CollectProcedures(
     180        Smoothie::Lexical::source,
     181        compiler.GetMeta().GetUserProcs(),
     182        compiler.GetMeta().GetDllProcs()
     183    );
     184
     185    // クラス情報を取得（※注 - CollectProceduresの後に呼び出す）
    182186    compiler.GetMeta().GetClasses().GetAllClassInfo();
    183187
    184188    // サブルーチン（ユーザー定義、DLL関数）のイテレータの準備
    185189    compiler.GetMeta().GetUserProcs().Iterator_Init();
     190    compiler.GetMeta().GetDllProcs().Iterator_Init();
     191
    186192
    187193    /*

  • trunk/abdev/BasicCompiler_Common/BasicCompiler.h

    r206 r209  
    2323DWORD ImageBase;
    2424INCLUDEFILEINFO IncludeFileInfo;
    25 DllProc **ppDeclareHash;
    2625
    2726ERRORINFO *pErrorInfo;

  • trunk/abdev/BasicCompiler_Common/MakeExe.cpp

    r206 r209  
    164164    extern LINEINFO *pLineInfo;
    165165    HeapDefaultFree(pLineInfo);
    166 
    167     //Declare（DLL関数）情報のメモリ解放
    168     DeleteDeclareInfo();
    169166
    170167    //コンパイルダイアログのプログレスバーを上げる

  • trunk/abdev/BasicCompiler_Common/Subroutine.cpp

    r206 r209  
    277277}
    278278
    279 
    280 void AddDeclareData(const NamespaceScopes &namespaceScopes, char *buffer,int nowLine){
    281     extern HANDLE hHeap;
    282     int i2;
    283 
    284     int i=0;
    285 
    286     //Sub/Function
    287     Procedure::Kind kind = Procedure::Sub;
    288     if(buffer[i]==ESC_SUB){
    289     }
    290     else if(buffer[i]==ESC_FUNCTION){
    291         kind = Procedure::Function;
    292     }
    293     else{
    294         SetError(1,NULL,nowLine);
    295         return;
    296     }
    297     i++;
    298 
    299     //プロシージャ名
    300     char procName[VN_SIZE];
    301     bool isCdecl = false;
    302     for(i2=0;;i++,i2++){
    303         if(buffer[i]==1&&buffer[i+1]==ESC_CDECL){
    304             isCdecl = true;
    305 
    306             i+=2;
    307             procName[i2]=0;
    308             break;
    309         }
    310         if(buffer[i]==','){
    311             procName[i2]=0;
    312             break;
    313         }
    314         if(buffer[i]=='\0'){
    315             SetError(1,NULL,nowLine);
    316             return;
    317         }
    318         procName[i2]=buffer[i];
    319     }
    320     i++;
    321 
    322     //ユーザー定義関数との重複チェック
    323     if(GetSubHash(procName)){
    324         SetError(15,procName,nowLine);
    325         return;
    326     }
    327 
    328 
    329     //ライブラリ
    330     char dllFileName[MAX_PATH];
    331     i = GetOneParameter( buffer, i, dllFileName );
    332     Type resultType;
    333     _int64 i64data;
    334     if( !StaticCalculation( true, dllFileName, 0, &i64data, resultType ) ){
    335         return;
    336     }
    337     if( resultType.GetBasicType() != typeOfPtrChar ){
    338         SetError(1,NULL,nowLine);
    339         return;
    340     }
    341     lstrcpy( dllFileName, (char *)i64data );
    342     CharUpper(dllFileName);
    343     if(!strstr(dllFileName,".")){
    344         lstrcat(dllFileName,".DLL");
    345         if(lstrlen(dllFileName)>=16){
    346             SetError(7,NULL,nowLine);
    347             return;
    348         }
    349     }
    350 
    351     //エイリアス
    352     char alias[VN_SIZE];
    353     i = GetOneParameter( buffer, i, alias );
    354     if( alias[0] ){
    355         if( !StaticCalculation( true, alias, 0, &i64data, resultType ) ){
    356             return;
    357         }
    358         if( resultType.GetBasicType() != typeOfPtrChar ){
    359             SetError(1,NULL,nowLine);
    360             return;
    361         }
    362         lstrcpy( alias, (char *)i64data );
    363     }
    364     else{
    365         //省略されたときは関数名
    366         lstrcpy( alias, procName );
    367     }
    368 
    369 
    370     // オブジェクトを生成
    371     DllProc *pDllProc = new DllProc( namespaceScopes, procName, kind, isCdecl, dllFileName, alias );
    372 
    373     // パラメータを解析
    374     // ※第1パラメータにに指定するデータの例："( s As String ) As String"
    375     pDllProc->SetParamsAndReturnType( buffer + i, nowLine );
    376 
    377     // パラメータのエラーチェック
    378     BOOST_FOREACH( const Parameter *pParam, pDllProc->Params() ){
    379         if( pParam->IsObject() ){
    380             SetError(25,pParam->GetVarName(),nowLine);
    381         }
    382         if( !pParam->IsRef() ){
    383             if( pParam->IsStruct() ){
    384                 SetError(28,pParam->GetVarName(),nowLine);
    385             }
    386         }
    387     }
    388 
    389     //戻り値のエラーチェック
    390     if( pDllProc->IsFunction() ){
    391         // Function定義
    392 
    393         if( pDllProc->ReturnType().IsObject() ){
    394             // DLL関数ではオブジェクトを戻り値にできない
    395             SetError(40,pDllProc->GetName(),nowLine);
    396         }
    397     }
    398 
    399 
    400     /////////////////////////////////
    401     // 格納位置を計算してppDeclareHashにセット
    402     /////////////////////////////////
    403 
    404     //ハッシュ値を取得
    405     int key;
    406     key=hash_default(procName);
    407 
    408     extern DllProc **ppDeclareHash;
    409     if(ppDeclareHash[key]){
    410         DllProc *pTempProc = ppDeclareHash[key];
    411         while(1){
    412             if( pTempProc->IsEqualSymbol( pDllProc->GetNamespaceScopes(), pDllProc->GetName() ) ){
    413                 //重複エラー
    414                 SetError(15,procName,nowLine);
    415                 return;
    416             }
    417 
    418             if(pTempProc->pNextData==0){
    419                 pTempProc->pNextData=pDllProc;
    420                 break;
    421             }
    422             pTempProc=pTempProc->pNextData;
    423         }
    424         pTempProc=pTempProc->pNextData;
    425     }
    426     else{
    427         ppDeclareHash[key]=pDllProc;
    428     }
    429 }
    430 
    431 void UserProcs::CollectUserProcs( const BasicSource &source, UserProcs &userProcs )
     279void CollectProcedures( const BasicSource &source, UserProcs &userProcs, DllProcs &dllProcs )
    432280{
    433281    extern HANDLE hHeap;
    … …  
    435283    char temporary[8192];
    436284
    437     //Declare（DLL関数）情報を初期化
    438     extern DllProc **ppDeclareHash;
    439     ppDeclareHash=(DllProc **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(DllProc *));
    440 
    441285    //サブルーチン（ユーザー定義）情報を初期化
    442286    userProcs.Clear();
     287
     288    //Declare（DLL関数）情報を初期化
     289    dllProcs.Clear();
    443290
    444291    // 名前空間管理
    … …  
    522369                if(source[i]=='\0') break;
    523370            }
    524             AddDeclareData(namespaceScopes,temporary,i);
     371            dllProcs.Add(namespaceScopes,temporary,i);
    525372
    526373            continue;
    … …  
    600447    delete pDllProc;
    601448}
    602 void DeleteDeclareInfo(void){
    603     //DLL情報を解放
    604     extern DllProc **ppDeclareHash;
    605     int i;
    606     for(i=0;i<MAX_HASH;i++){
    607         if(!ppDeclareHash[i]) continue;
    608 
    609         Delete_di(ppDeclareHash[i]);
    610     }
    611     HeapDefaultFree(ppDeclareHash);
    612 }
    613449
    614450bool IsNeedProcCompile(){

  • trunk/abdev/BasicCompiler_Common/common.h

    r206 r209  
    232232//hash.cpp
    233233int hash_default(const char *name);
    234 DllProc *GetDeclareHash(char *name);
     234DllProc *GetDeclareHash(const char *name);
    235235void GetOverloadSubHash( const char *lpszName, std::vector<const UserProc *> &subs );
    236236const UserProc *GetSubHash(const char *name,BOOL bError=0);
    … …  
    278278//MakeExe.cpp
    279279void StepCompileProgress(void);
    280 void DeleteDeclareInfo(void);
    281280void AddSourceCode(char *buffer);
    282281void OutputExe(void);
    … …  
    364363bool GetReturnTypeOfPropertyMethod( const char *variable, const char *rightSide, Type &resultType );
    365364bool GetReturnTypeOfIndexerGetterProc( const CClass &objClass, Type &resultType );
    366 void DeleteDeclareInfo(void);
    367365int AddProcPtrInfo( const string &typeExpression, int nowLine );
    368366bool IsNeedProcCompile();

  • trunk/abdev/BasicCompiler_Common/hash.cpp

    r206 r209  
    2323}
    2424
    25 DllProc *GetDeclareHash(char *fullName){
    26     char ObjName[VN_SIZE];      //オブジェクト変数
    27     char NestMember[VN_SIZE];   //入れ子メンバ
    28     bool isObjectMember = SplitMemberName( fullName, ObjName, NestMember );
     25DllProc *GetDeclareHash(const char *fullName){
     26    char namespaceStr[VN_SIZE];     //オブジェクト変数
     27    char simpleName[VN_SIZE];   //入れ子メンバ
     28    bool isObjectMember = SplitMemberName( fullName, namespaceStr, simpleName );
    2929
    30     //ハッシュ値を取得
    31     int key;
    32     key=hash_default(NestMember);
     30    ///////////////////////////
     31    // グローバル関数を検索
     32    ///////////////////////////
    3333
    34     //格納位置を取得
    35     extern DllProc **ppDeclareHash;
    36     DllProc *pDllProc;
    37     pDllProc=ppDeclareHash[key];
     34    // ハッシュ値を取得
     35    DllProc *pDllProc = compiler.GetMeta().GetDllProcs().GetHashArrayElement( simpleName );
    3836    while(pDllProc){
    39         // TODO: Declare名前空間対応
    4037        if( pDllProc->IsEqualSymbol( fullName ) ){
    41             break;
     38            return pDllProc;
    4239        }
    4340
    44         pDllProc=pDllProc->pNextData;
     41        pDllProc=pDllProc->GetChainNext();
    4542    }
    4643
    47     return pDllProc;
     44    return NULL;
    4845}
    4946

  • trunk/abdev/BasicCompiler_Common/include/MetaImpl.h

    r206 r209  
    1818    // 関数・メソッド
    1919    UserProcs userProcs;
     20
     21    // DLL関数
     22    DllProcs dllProcs;
    2023
    2124    // クラス
    … …  
    5356        ar & BOOST_SERIALIZATION_NVP( namespaceScopesCollection );
    5457        ar & BOOST_SERIALIZATION_NVP( userProcs );
     58        ar & BOOST_SERIALIZATION_NVP( dllProcs );
    5559        ar & BOOST_SERIALIZATION_NVP( classesImpl );
    5660        ar & BOOST_SERIALIZATION_NVP( globalVars );
    … …  
    8791    {
    8892        return userProcs;
     93    }
     94
     95    const DllProcs &GetDllProcs() const
     96    {
     97        return dllProcs;
     98    }
     99    DllProcs &GetDllProcs()
     100    {
     101        return dllProcs;
    89102    }
    90103

  • trunk/abdev/BasicCompiler_Common/include/Procedure.h

    r208 r209  
    205205    }
    206206
    207     bool IsMacro() const
    208     {
    209         return isMacro;
    210     }
    211 
    212     int GetSecondParmNum() const
    213     {
    214         return secondParmNum;
    215     }
    216     const Parameters &RealParams() const
    217     {
    218         return realParams;
    219     }
    220     int GetRealSecondParmNum() const
    221     {
    222         return realSecondParmNum;
    223     }
    224 
    225     void ExportOff(){
    226         isExport = false;
    227     }
    228     bool IsExport() const
    229     {
    230         return isExport;
    231     }
    232     void ThisIsSystemProc() const
    233     {
    234         isSystem = true;
    235     }
    236     bool IsSystem() const
    237     {
    238         return isSystem;
    239     }
    240     void ThisIsAutoGenerationProc() const
    241     {
    242         isAutoGeneration = true;
    243     }
    244     bool IsAutoGeneration() const
    245     {
    246         return isAutoGeneration;
    247     }
    248     void CompleteCompile() const
    249     {
    250         isCompiled = true;
    251     }
    252     void KillCompileStatus() const
    253     {
    254         isCompiled = false;
    255     }
    256     bool IsCompiled() const
    257     {
    258         return isCompiled;
    259     }
    260     bool IsDestructor() const
    261     {
    262         return ( GetName()[0] == '~' );
    263     }
    264 
    265     // バイナリコード位置とサイズ
    266     DWORD GetBeginOpAddress() const
    267     {
    268         return beginOpAddress;
    269     }
    270     void SetBeginOpAddress( DWORD beginOpAddress ) const
    271     {
    272         this->beginOpAddress = beginOpAddress;
    273     }
    274     DWORD GetEndOpAddress() const
    275     {
    276         return endOpAddress;
    277     }
    278     void SetEndOpAddress( DWORD endOpAddress ) const
    279     {
    280         this->endOpAddress = endOpAddress;
    281     }
    282     int GetCodeSize() const
    283     {
    284         return endOpAddress - beginOpAddress;
    285     }
    286 
    287     virtual const NamespaceScopes &GetNamespaceScopes() const;
    288     const NamespaceScopesCollection &GetImportedNamespaces() const;
    289 
    290     Variables &GetLocalVars() const
    291     {
    292         return localVars;
    293     }
    294 
    295     int GetId() const
    296     {
    297         return id;
    298     }
    299 
    300     std::string GetFullName() const;
    301 
    302207    virtual bool IsDuplication( const UserProc *pUserProc ) const
    303208    {
    … …  
    311216    }
    312217
     218    bool IsMacro() const
     219    {
     220        return isMacro;
     221    }
     222
     223    int GetSecondParmNum() const
     224    {
     225        return secondParmNum;
     226    }
     227    const Parameters &RealParams() const
     228    {
     229        return realParams;
     230    }
     231    int GetRealSecondParmNum() const
     232    {
     233        return realSecondParmNum;
     234    }
     235
     236    void ExportOff(){
     237        isExport = false;
     238    }
     239    bool IsExport() const
     240    {
     241        return isExport;
     242    }
     243    void ThisIsSystemProc() const
     244    {
     245        isSystem = true;
     246    }
     247    bool IsSystem() const
     248    {
     249        return isSystem;
     250    }
     251    void ThisIsAutoGenerationProc() const
     252    {
     253        isAutoGeneration = true;
     254    }
     255    bool IsAutoGeneration() const
     256    {
     257        return isAutoGeneration;
     258    }
     259    void CompleteCompile() const
     260    {
     261        isCompiled = true;
     262    }
     263    void KillCompileStatus() const
     264    {
     265        isCompiled = false;
     266    }
     267    bool IsCompiled() const
     268    {
     269        return isCompiled;
     270    }
     271    bool IsDestructor() const
     272    {
     273        return ( GetName()[0] == '~' );
     274    }
     275
     276    // バイナリコード位置とサイズ
     277    DWORD GetBeginOpAddress() const
     278    {
     279        return beginOpAddress;
     280    }
     281    void SetBeginOpAddress( DWORD beginOpAddress ) const
     282    {
     283        this->beginOpAddress = beginOpAddress;
     284    }
     285    DWORD GetEndOpAddress() const
     286    {
     287        return endOpAddress;
     288    }
     289    void SetEndOpAddress( DWORD endOpAddress ) const
     290    {
     291        this->endOpAddress = endOpAddress;
     292    }
     293    int GetCodeSize() const
     294    {
     295        return endOpAddress - beginOpAddress;
     296    }
     297
     298    virtual const NamespaceScopes &GetNamespaceScopes() const;
     299    const NamespaceScopesCollection &GetImportedNamespaces() const;
     300
     301    Variables &GetLocalVars() const
     302    {
     303        return localVars;
     304    }
     305
     306    int GetId() const
     307    {
     308        return id;
     309    }
     310
     311    std::string GetFullName() const;
     312
    313313    bool IsVirtual() const;
    314314
    … …  
    393393
    394394    void EnumGlobalProcs( const char *simpleName, const char *localName, std::vector<const UserProc *> &subs );
    395 
    396     static void CollectUserProcs( const BasicSource &source, UserProcs &userProcs );
    397 };
    398 
    399 class DllProc : public Procedure
     395};
     396
     397class DllProc : public Procedure, public Jenga::Common::ObjectInHashmap<DllProc>
    400398{
    401399    string dllFileName;
    … …  
    428426    {
    429427    }
    430     ~DllProc(){}
     428    ~DllProc()
     429    {
     430    }
     431
     432    virtual const std::string &GetKeyName() const
     433    {
     434        return GetName();
     435    }
     436
     437    virtual bool IsDuplication( const DllProc *pDllProc ) const
     438    {
     439        if( pDllProc->IsEqualSymbol( *this )
     440            && this->Params().Equals( pDllProc->Params() ) )
     441        {
     442            return true;
     443        }
     444        return false;
     445    }
    431446
    432447    const string &GetDllFileName() const
    … …  
    449464    bool SetParamsAndReturnType( const char *sourceOfParams, int nowLine );
    450465};
     466class DllProcs : public Jenga::Common::Hashmap<DllProc>
     467{
     468    // XMLシリアライズ用
     469private:
     470    friend class boost::serialization::access;
     471    template<class Archive> void serialize(Archive& ar, const unsigned int version)
     472    {
     473        trace_for_serialize( "serializing - DllProcs" );
     474
     475        ar & boost::serialization::make_nvp("Hashmap_DllProc",
     476            boost::serialization::base_object<Jenga::Common::Hashmap<DllProc>>(*this));
     477    }
     478
     479public:
     480    void Add(const NamespaceScopes &namespaceScopes, char *buffer,int nowLine);
     481};
     482
     483void CollectProcedures( const BasicSource &source, UserProcs &userProcs, DllProcs &dllProcs );
    451484
    452485class ProcPointer : public Procedure

  • trunk/abdev/BasicCompiler_Common/src/Procedure.cpp

    r208 r209  
    759759}
    760760
     761void DllProcs::Add(const NamespaceScopes &namespaceScopes, char *buffer,int nowLine){
     762    int i2;
     763
     764    int i=0;
     765
     766    //Sub/Function
     767    Procedure::Kind kind = Procedure::Sub;
     768    if(buffer[i]==ESC_SUB){
     769    }
     770    else if(buffer[i]==ESC_FUNCTION){
     771        kind = Procedure::Function;
     772    }
     773    else{
     774        SetError(1,NULL,nowLine);
     775        return;
     776    }
     777    i++;
     778
     779    //プロシージャ名
     780    char procName[VN_SIZE];
     781    bool isCdecl = false;
     782    for(i2=0;;i++,i2++){
     783        if(buffer[i]==1&&buffer[i+1]==ESC_CDECL){
     784            isCdecl = true;
     785
     786            i+=2;
     787            procName[i2]=0;
     788            break;
     789        }
     790        if(buffer[i]==','){
     791            procName[i2]=0;
     792            break;
     793        }
     794        if(buffer[i]=='\0'){
     795            SetError(1,NULL,nowLine);
     796            return;
     797        }
     798        procName[i2]=buffer[i];
     799    }
     800    i++;
     801
     802    //ユーザー定義関数との重複チェック
     803    if(GetSubHash(procName)){
     804        SetError(15,procName,nowLine);
     805        return;
     806    }
     807
     808
     809    //ライブラリ
     810    char dllFileName[MAX_PATH];
     811    i = GetOneParameter( buffer, i, dllFileName );
     812    Type resultType;
     813    _int64 i64data;
     814    if( !StaticCalculation( true, dllFileName, 0, &i64data, resultType ) ){
     815        return;
     816    }
     817    if( resultType.GetBasicType() != typeOfPtrChar ){
     818        SetError(1,NULL,nowLine);
     819        return;
     820    }
     821    lstrcpy( dllFileName, (char *)i64data );
     822    CharUpper(dllFileName);
     823    if(!strstr(dllFileName,".")){
     824        lstrcat(dllFileName,".DLL");
     825        if(lstrlen(dllFileName)>=16){
     826            SetError(7,NULL,nowLine);
     827            return;
     828        }
     829    }
     830
     831    //エイリアス
     832    char alias[VN_SIZE];
     833    i = GetOneParameter( buffer, i, alias );
     834    if( alias[0] ){
     835        if( !StaticCalculation( true, alias, 0, &i64data, resultType ) ){
     836            return;
     837        }
     838        if( resultType.GetBasicType() != typeOfPtrChar ){
     839            SetError(1,NULL,nowLine);
     840            return;
     841        }
     842        lstrcpy( alias, (char *)i64data );
     843    }
     844    else{
     845        //省略されたときは関数名
     846        lstrcpy( alias, procName );
     847    }
     848
     849
     850    // オブジェクトを生成
     851    DllProc *pDllProc = new DllProc( namespaceScopes, procName, kind, isCdecl, dllFileName, alias );
     852
     853    // パラメータを解析
     854    // ※第1パラメータにに指定するデータの例："( s As String ) As String"
     855    pDllProc->SetParamsAndReturnType( buffer + i, nowLine );
     856
     857    // パラメータのエラーチェック
     858    BOOST_FOREACH( const Parameter *pParam, pDllProc->Params() ){
     859        if( pParam->IsObject() ){
     860            SetError(25,pParam->GetVarName(),nowLine);
     861        }
     862        if( !pParam->IsRef() ){
     863            if( pParam->IsStruct() ){
     864                SetError(28,pParam->GetVarName(),nowLine);
     865            }
     866        }
     867    }
     868
     869    //戻り値のエラーチェック
     870    if( pDllProc->IsFunction() ){
     871        // Function定義
     872
     873        if( pDllProc->ReturnType().IsObject() ){
     874            // DLL関数ではオブジェクトを戻り値にできない
     875            SetError(40,pDllProc->GetName(),nowLine);
     876        }
     877    }
     878
     879    // ハッシュマップに追加
     880    this->Put( pDllProc );
     881}
     882
    761883bool ProcPointer::SetParamsAndReturnType( const char *sourceOfParams, int nowLine ){
    762884    int i = 0;
Note: See TracChangeset for help on using the changeset viewer.