Ignore:
Timestamp:
Mar 19, 2012, 1:59:48 AM (13 years ago)
Author:
イグトランス (egtra)
Message:

egtraブランチの内容をマージ。

Location:
trunk
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk

  • trunk/ab5.0/abdev

    • Property svn:ignore set to
      *.opensdf
      *.sdf
      *.suo
      *.user
      int
      ipch
      out

  • trunk/ab5.0/abdev/BasicCompiler_Common/src/BoostSerializationSupport.cpp

    r751 r828  
    1 #pragma warning(disable : 4996)
    2 
    31#include <map>
    42#include <string>
    … …  
    1917#include <limits.h>
    2018#include <shlobj.h>
    21 #include <process.h>
    22 #include <fcntl.h>
    23 #include <io.h>
    2419#include <shlwapi.h>
    2520#include <tchar.h>
    26 #include <stdarg.h>
    2721
    2822//boost libraries
    2923#include <boost/foreach.hpp>
    30 
     24#include <boost/cast.hpp>
     25
     26#pragma warning(push)
     27#pragma warning(disable: 4244 6326)
    3128#include <boost/archive/xml_oarchive.hpp>
    3229#include <boost/archive/xml_iarchive.hpp>
    … …  
    4138#include <boost/serialization/map.hpp>
    4239#include <boost/serialization/version.hpp>
    43 #include <boost/serialization/is_abstract.hpp>
     40#pragma warning(pop)
    4441
    4542#include <jenga/include/jenga.h>
    … …  
    4946using namespace Jenga::Common;
    5047
     48using boost::polymorphic_downcast;
     49
    5150template<class T_xml_schema> void BoostSerializationSupport<T_xml_schema>::echo( const char *msg ) const
    5251{
    53     MessageBox( NULL, msg, "XMLシリアライズの例外", MB_OK );
     52    MessageBox( NULL, msg, "シリアライズの例外", MB_OK );
    5453}
    5554template<class T_xml_schema> bool BoostSerializationSupport<T_xml_schema>::ReadXml( std::istream& ifs, bool isShowExceptionMessage )
    … …  
    6160
    6261        // ファイルから読込
    63         ia >> boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );
    64 
    65         isSuccessful = true;
    66     }
    67     catch( boost::archive::archive_exception e )
     62        ia >> boost::serialization::make_nvp( RootTagName(), *polymorphic_downcast<T_xml_schema*>(this) );
     63
     64        isSuccessful = true;
     65    }
     66    catch( boost::archive::archive_exception const& e )
    6867    {
    6968        if( isShowExceptionMessage )
    … …  
    9493
    9594        // ファイルに書き出し
    96         oa << boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );
    97 
    98         isSuccessful = true;
    99     }
    100     catch( boost::archive::archive_exception e )
     95        oa << boost::serialization::make_nvp( RootTagName(), *polymorphic_downcast<T_xml_schema const*>(this) );
     96
     97        isSuccessful = true;
     98    }
     99    catch( boost::archive::archive_exception const& e )
    101100    {
    102101        if( isShowExceptionMessage )
    … …  
    154153
    155154        // 文字列ストリームから読込
    156         ia >> boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );
     155        ia >> boost::serialization::make_nvp( RootTagName(), *polymorphic_downcast<T_xml_schema*>(this) );
    157156
    158157        isSuccessful = true;
    … …  
    179178
    180179        // 文字列ストリームに書き出し
    181         oa << boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );
    182 
    183         isSuccessful = true;
    184     }
    185     catch( boost::archive::archive_exception e )
     180        oa << boost::serialization::make_nvp( RootTagName(), *polymorphic_downcast<T_xml_schema const*>(this) );
     181
     182        isSuccessful = true;
     183    }
     184    catch( boost::archive::archive_exception const& e )
    186185    {
    187186        echo( e.what() );
    … …  
    211210
    212211        // ファイルから読込
    213         ia >> boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );
    214 
    215         isSuccessful = true;
    216     }
    217     catch( boost::archive::archive_exception e )
     212        ia >> boost::serialization::make_nvp( RootTagName(), *polymorphic_downcast<T_xml_schema*>(this) );
     213
     214        isSuccessful = true;
     215    }
     216    catch( boost::archive::archive_exception const& e )
    218217    {
    219218        if( isShowExceptionMessage )
    … …  
    249248
    250249        // ファイルに書き出し
    251         oa << boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );
    252 
    253         isSuccessful = true;
    254     }
    255     catch( boost::archive::archive_exception e )
     250        oa << boost::serialization::make_nvp( RootTagName(), *polymorphic_downcast<T_xml_schema const*>(this) );
     251
     252        isSuccessful = true;
     253    }
     254    catch( boost::archive::archive_exception const& e )
    256255    {
    257256        if( isShowExceptionMessage )
    … …  
    289288
    290289        // 文字列ストリームから読込
    291         ia >> boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );
    292 
    293         isSuccessful = true;
    294     }
    295     catch( boost::archive::archive_exception e )
     290        ia >> boost::serialization::make_nvp( RootTagName(), *polymorphic_downcast<T_xml_schema*>(this) );
     291
     292        isSuccessful = true;
     293    }
     294    catch( boost::archive::archive_exception const& e )
    296295    {
    297296        echo( e.what() );
    … …  
    313312
    314313        // 文字列ストリームに書き出し
    315         oa << boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );
    316 
    317         isSuccessful = true;
    318     }
    319     catch( boost::archive::archive_exception e )
     314        oa << boost::serialization::make_nvp( RootTagName(), *polymorphic_downcast<T_xml_schema const*>(this) );
     315
     316        isSuccessful = true;
     317    }
     318    catch( boost::archive::archive_exception const& e )
    320319    {
    321320        echo( e.what() );
    … …  
    342341
    343342        // ファイルから読込
    344         ia >> boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );
    345 
    346         isSuccessful = true;
    347     }
    348     catch( boost::archive::archive_exception e )
     343        ia >> boost::serialization::make_nvp( RootTagName(), *polymorphic_downcast<T_xml_schema*>(this) );
     344
     345        isSuccessful = true;
     346    }
     347    catch( boost::archive::archive_exception const& e )
    349348    {
    350349        if( isShowExceptionMessage )
    … …  
    380379
    381380        // ファイルに書き出し
    382         oa << boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );
    383 
    384         isSuccessful = true;
    385     }
    386     catch( boost::archive::archive_exception e )
     381        oa << boost::serialization::make_nvp( RootTagName(), *polymorphic_downcast<T_xml_schema const*>(this) );
     382
     383        isSuccessful = true;
     384    }
     385    catch( boost::archive::archive_exception const& e )
    387386    {
    388387        if( isShowExceptionMessage )
    … …  
    420419
    421420        // 文字列ストリームから読込
    422         ia >> boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );
     421        ia >> boost::serialization::make_nvp( RootTagName(), *polymorphic_downcast<T_xml_schema*>(this) );
    423422
    424423        isSuccessful = true;
    … …  
    445444
    446445        // 文字列ストリームに書き出し
    447         oa << boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );
    448 
    449         isSuccessful = true;
    450     }
    451     catch( boost::archive::archive_exception e )
     446        oa << boost::serialization::make_nvp( RootTagName(), *polymorphic_downcast<T_xml_schema const*>(this) );
     447
     448        isSuccessful = true;
     449    }
     450    catch( boost::archive::archive_exception const& e )
    452451    {
    453452        echo( e.what() );
    … …  
    478477
    479478        // 文字列ストリームから読込
    480         ia >> boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );
     479        ia >> boost::serialization::make_nvp( RootTagName(), *polymorphic_downcast<T_xml_schema*>(this) );
    481480
    482481        isSuccessful = true;

  • trunk/ab5.0/abdev/BasicCompiler_Common/src/Compiler.cpp

    r750 r828  
    353353const std::string Compiler::TypeToString( const Type &type )
    354354{
    355     if( PTR_LEVEL( type.GetBasicType() ) ){
     355    if(type.GetBasicType() != DEF_NON && PTR_LEVEL( type.GetBasicType() ) ){
    356356        //ポインタレベルが1以上の場合
    357357        Type tempType( type );

  • trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer.cpp

    r625 r828  
    33using namespace ActiveBasic::Compiler;
    44
    5 bool LexicalAnalyzer::CollectNamespaces( const char *source, NamespaceScopesCollection &namespaceScopesCollection )
     5using boost::numeric_cast;
     6
     7bool LexicalAnalyzer::CollectNamespaces(char const* source, NamespaceScopesCollection &namespaceScopesCollection)
    68{
    7     int i, i2;
    8     char temporary[1024];
    9 
    109    bool isSuccessful = true;
    1110
    … …  
    1312    NamespaceScopes namespaceScopes;
    1413
    15     for(i=0;;i++){
     14    for (int i = 0; ; i++)
     15    {
    1616        if(source[i]=='\0') break;
    1717
    1818        if( source[i] == 1 && source[i+1] == ESC_NAMESPACE ){
    19             for(i+=2,i2=0;;i2++,i++){
    20                 if( IsCommandDelimitation( source[i] ) ){
    21                     temporary[i2]=0;
    22                     break;
    23                 }
    24                 temporary[i2]=source[i];
     19            i+=2;
     20            char const* p = &source[i];
     21            while (!IsCommandDelimitation(source[i]))
     22            {
     23                ++i;
    2524            }
    26             namespaceScopes.push_back( temporary );
     25            namespaceScopes.push_back(std::string(p, &source[i]));
    2726
    2827            if( !namespaceScopesCollection.IsExist( namespaceScopes ) ){
    … …  
    4645    }
    4746
    48     if( namespaceScopes.size() > 0 ){
     47    if( !namespaceScopes.empty() ){
    4948        compiler.errorMessenger.Output( 63, NULL, cp );
    5049        isSuccessful = false;

  • trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Class.cpp

    r750 r828  
    1515void LexicalAnalyzer::CollectClassesForNameOnly( const char *source, Classes &classes )
    1616{
    17     int i, i2;
     17    int i2;
    1818    char temporary[VN_SIZE];
    1919
    … …  
    2525    compiler.GetNamespaceSupporter().ClearImportedNamespaces();
    2626
    27     for(i=0;;i++){
     27    for(int i=0;;i++){
    2828        if(source[i]=='\0') break;
    2929
    3030        if( source[i] == 1 && source[i+1] == ESC_NAMESPACE ){
    31             for(i+=2,i2=0;;i2++,i++){
    32                 if( IsCommandDelimitation( source[i] ) ){
    33                     temporary[i2]=0;
    34                     break;
    35                 }
    36                 temporary[i2]=source[i];
    37             }
    38             namespaceScopes.push_back( temporary );
     31            i+=2;
     32            char const* p = &source[i];
     33            while (!IsCommandDelimitation(source[i]))
     34            {
     35                ++i;
     36            }
     37            namespaceScopes.push_back(std::string(p, &source[i]));
    3938
    4039            continue;
    … …  
    5251        }
    5352        else if( source[i] == 1 && source[i+1] == ESC_IMPORTS ){
    54             for(i+=2,i2=0;;i2++,i++){
    55                 if( IsCommandDelimitation( source[i] ) ){
    56                     temporary[i2]=0;
    57                     break;
    58                 }
    59                 temporary[i2]=source[i];
    60             }
    61             if( !compiler.GetNamespaceSupporter().ImportsNamespace( temporary ) )
    62             {
    63                 compiler.errorMessenger.Output(64,temporary,i );
     53            i+=2;
     54            char const* p = &source[i];
     55            while (!IsCommandDelimitation(source[i]))
     56            {
     57                ++i;
     58            }
     59            std::string s(p, &source[i]);
     60            if (!compiler.GetNamespaceSupporter().ImportsNamespace(s))
     61            {
     62                compiler.errorMessenger.Output(64, s.c_str(), i);
    6463            }
    6564
    … …  
    13481347    delete pobj_LoopRefCheck;
    13491348    pobj_LoopRefCheck=0;
    1350 
    1351     // イテレータの準備
    1352     classes.Iterator_Init();
    13531349}
    13541350
    … …  
    14121408
    14131409    compiler.GetObjectModule().meta.GetUserProcs().Put( pUserProc );
    1414     compiler.GetObjectModule().meta.GetUserProcs().Iterator_Init();
    14151410
    14161411    LexicalAnalyzer::AddMethod(
    … …  
    15221517        else
    15231518        {
    1524             for( int i=0; i<pInterface->GetDynamicMethods().size(); i++ )
     1519            for( std::size_t i=0; i<pInterface->GetDynamicMethods().size(); i++ )
    15251520            {
    15261521                if( pInterface->GetDynamicMethods()[i]->IsAbstract() != pExpandedInterface->GetDynamicMethods()[i]->IsAbstract() )

  • trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Const.cpp

    r637 r828  
    8585
    8686    int i2;
    87     char temporary[1024];
    8887
    8988    // 名前空間管理
    … …  
    9190    namespaceScopes.clear();
    9291
    93     for(int i=0;;i++){
     92    for (int i = 0; ; ++i)
     93    {
    9494        if( source[i] == '\0' ) break;
    9595
    9696        if( source[i] == 1 && source[i+1] == ESC_NAMESPACE ){
    97             for(i+=2,i2=0;;i2++,i++){
    98                 if( IsCommandDelimitation( source[i] ) ){
    99                     temporary[i2]=0;
    100                     break;
    101                 }
    102                 temporary[i2]=source[i];
    103             }
    104             namespaceScopes.push_back( temporary );
     97            i+=2;
     98            char const* p = &source[i];
     99            while (!IsCommandDelimitation(source[i]))
     100            {
     101                ++i;
     102            }
     103            namespaceScopes.push_back(std::string(p, &source[i]));
    105104
    106105            continue;
    … …  
    131130                }
    132131
     132                char const* beginTemp = &source[i];
     133                char const* endTemp = &source[i];
     134
    133135                for(i2=0;;i++,i2++){
    134136                    if(source[i]=='\"'){
    135                         temporary[i2]=source[i];
    136137                        for(i++,i2++;;i++,i2++){
    137                             temporary[i2]=source[i];
    138138                            if(source[i]=='\"') break;
    139139                        }
    … …  
    141141                    }
    142142                    if(IsCommandDelimitation(source[i])){
    143                         temporary[i2]=0;
     143                        endTemp = beginTemp + i2;
    144144                        break;
    145145                    }
    146                     temporary[i2]=source[i];
    147146                }
    148147
    149148                //名前を取得
    150                 char name[VN_SIZE];
     149                char const* nameEnd;
    151150                for(i2=0;;i2++){
    152                     if(temporary[i2]=='\0'){
     151                    if(beginTemp[i2]=='\0'){
    153152                        compiler.errorMessenger.Output(10,"Const",cp);
    154153                        return;
    155154                    }
    156                     if(temporary[i2]=='='||temporary[i2]=='('){
    157                         name[i2]=0;
     155                    if(beginTemp[i2]=='='||beginTemp[i2]=='('){
     156                        nameEnd = beginTemp + i2;
    158157                        break;
    159158                    }
    160                     name[i2]=temporary[i2];
    161                 }
     159                }
     160                std::string name(beginTemp, nameEnd);
    162161
    163162                //重複チェック
    … …  
    165164                    || compiler.GetObjectModule().meta.GetGlobalConsts().IsExistDuplicationKeyName( name ) )
    166165                {
    167                     compiler.errorMessenger.Output(15,name,cp);
     166                    compiler.errorMessenger.Output(15, name, cp);
    168167                    return;
    169168                }
    170169
    171                 if( temporary[i2] == '=' )
     170                if( beginTemp[i2] == '=' )
    172171                {
    173172                    // 定数
    174                     const char *expression = temporary + i2 + 1;
     173                    std::string expression(beginTemp + i2 + 1, endTemp);
    175174
    176175                    _int64 i64data;
    177176                    Type resultType;
    178                     if( StaticCalculation(false, expression, 0, &i64data, resultType) )
     177                    if( StaticCalculation(false, expression.c_str(), 0, &i64data, resultType) )
    179178                    {
    180179                        consts.Add( Symbol( namespaceScopes, name ), i64data, resultType );
    … …  
    184183                {
    185184                    // 定数マクロ
    186                     const char *params = temporary + i2;
    187                     if( !constMacros.Add( Symbol( namespaceScopes, name ), params ) )
     185                    std::string params(beginTemp + i2, endTemp);
     186                    if( !constMacros.Add( Symbol( namespaceScopes, name ), params.c_str() ) )
    188187                    {
    189188                        compiler.errorMessenger.Output( 1, NULL, i );
    … …  
    206205        }
    207206    }
    208 
    209     // イテレータを初期化
    210     compiler.GetObjectModule().meta.GetGlobalConsts().Iterator_Init();
    211     compiler.GetObjectModule().meta.GetGlobalConstMacros().Iterator_Init();
    212 }
    213 
    214 bool LexicalAnalyzer::ConstMacroToExpression( const ConstMacro &constMacro, const char *parameterStr, char *dest )
    215 {
    216     extern HANDLE hHeap;
    217     int i2,i3,i4,num;
     207}
     208
     209bool LexicalAnalyzer::ConstMacroToExpression( const ConstMacro &constMacro, const char *parameterStr, char *dest, std::size_t destSize )
     210{
     211    std::string s;
     212    auto ret = ConstMacroToExpression(constMacro, parameterStr, s);
     213    strcpy_s(dest, destSize, s.c_str());
     214    return ret;
     215}
     216
     217bool LexicalAnalyzer::ConstMacroToExpression( const ConstMacro &constMacro, const char *parameterStr, std::string& dest )
     218{
     219    int i2,i3;
    218220    char temporary[VN_SIZE];
    219     char *pParms[MAX_PARMS];
    220     num=0;
     221    std::vector<std::string> Parms;
     222    dest.reserve(8192);
    221223    i2=0;
    222224    while(1){
    223225        i2=GetOneParameter(parameterStr,i2,temporary);
    224226
    225         pParms[num]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
    226         lstrcpy(pParms[num],temporary);
    227 
    228         num++;
     227        Parms.push_back(temporary);
     228
    229229        if(parameterStr[i2]=='\0') break;
    230230    }
    231     if( num != constMacro.GetParameters().size() ){
     231    if( Parms.size() != constMacro.GetParameters().size() ){
    232232        extern int cp;
    233         for(i2=0;i2<num;i2++) HeapDefaultFree(pParms[i2]);
    234233        compiler.errorMessenger.Output(10,constMacro.GetName().c_str(),cp);
    235         lstrcpy(dest,"0");
     234        dest = '0';
    236235        return true;
    237236    }
    238237
    239238    i2=0;
    240     i4=0;
    241239    while(1){
    242240
    … …  
    257255        if( i3 == (int)constMacro.GetParameters().size() ){
    258256            //パラメータでないとき
    259             lstrcpy(dest+i4,temporary);
    260             i4+=lstrlen(temporary);
     257            dest += temporary;
    261258        }
    262259        else{
    263260            //パラメータのとき
    264             lstrcpy(dest+i4,pParms[i3]);
    265             i4+=lstrlen(pParms[i3]);
     261            dest += Parms[i3];
    266262        }
    267263
    268264        //演算子をコピー
    269         for(;;i2++,i4++){
     265        for(;;i2++){
    270266            if( constMacro.GetExpression()[i2] == 1 ){
    271                 dest[i4++] = constMacro.GetExpression()[i2++];
    272                 dest[i4] = constMacro.GetExpression()[i2];
     267                dest += constMacro.GetExpression()[i2++];
     268                dest += constMacro.GetExpression()[i2];
    273269                continue;
    274270            }
    275271            if(IsVariableTopChar( constMacro.GetExpression()[i2] )) break;
    276             dest[i4] = constMacro.GetExpression()[i2];
     272            dest += constMacro.GetExpression()[i2];
    277273            if( constMacro.GetExpression()[i2] == '\0' ) break;
    278274        }
    … …  
    281277    }
    282278
    283     for(i2=0;i2<num;i2++) HeapDefaultFree(pParms[i2]);
    284 
    285279    return true;
    286280}

  • trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Delegate.cpp

    r750 r828  
    55void LexicalAnalyzer::CollectDelegates( const char *source, Delegates &delegates )
    66{
    7     int i2;
    8     char temporary[VN_SIZE];
    9 
    107    // 名前空間管理
    118    NamespaceScopes &namespaceScopes = compiler.GetNamespaceSupporter().GetLivingNamespaceScopes();
    … …  
    1512    compiler.GetNamespaceSupporter().ClearImportedNamespaces();
    1613
    17     int length = lstrlen( source );
    18     for( int i=0; i<length; i++ )
     14    for (int i=0; source[i] != '\0'; i++)
    1915    {
    2016        if( source[i] == 1 && source[i+1] == ESC_NAMESPACE ){
    21             for(i+=2,i2=0;;i2++,i++){
    22                 if( IsCommandDelimitation( source[i] ) ){
    23                     temporary[i2]=0;
    24                     break;
    25                 }
    26                 temporary[i2]=source[i];
    27             }
    28             namespaceScopes.push_back( temporary );
     17            i+=2;
     18            char const* p = &source[i];
     19            while (!IsCommandDelimitation(source[i]))
     20            {
     21                ++i;
     22            }
     23            namespaceScopes.push_back(std::string(p, &source[i]));
    2924
    3025            continue;
    … …  
    4237        }
    4338        else if( source[i] == 1 && source[i+1] == ESC_IMPORTS ){
    44             for(i+=2,i2=0;;i2++,i++){
    45                 if( IsCommandDelimitation( source[i] ) ){
    46                     temporary[i2]=0;
    47                     break;
    48                 }
    49                 temporary[i2]=source[i];
    50             }
    51             if( !compiler.GetNamespaceSupporter().ImportsNamespace( temporary ) )
    52             {
    53                 compiler.errorMessenger.Output(64,temporary,i );
     39            i+=2;
     40            char const* p = &source[i];
     41            while (!IsCommandDelimitation(source[i]))
     42            {
     43                ++i;
     44            }
     45            std::string s(p, &source[i]);
     46            if (!compiler.GetNamespaceSupporter().ImportsNamespace(s))
     47            {
     48                compiler.errorMessenger.Output(64, s.c_str(), i);
    5449            }
    5550
    … …  
    112107                {
    113108                    compiler.errorMessenger.Output(-104,name,nowLine);
    114                     lstrcpy( returnTypeName, "Double" );
     109                    strcpy( returnTypeName, "Double" );
    115110                }
    116111            }
    … …  
    127122    Jenga::Common::SourceTemplate sourceTemplate( ActiveBasic::Common::Environment::GetAbdevSystemDirPath() + "\\templates\\delegate_class.tab" );
    128123
    129     delegates.Iterator_Reset();
    130     while( delegates.Iterator_HasNext() )
    131     {
    132         const Delegate &dg = *delegates.Iterator_GetNext();
     124    foreach (auto pDelegate, delegates)
     125    {
     126        const Delegate &dg = *pDelegate;
    133127
    134128        if( dg.IsExternal() )
    … …  
    263257void LexicalAnalyzer::RefleshDelegatesParameterAndReturnType( Delegates &delegates )
    264258{
    265     delegates.Iterator_Reset();
    266     while( delegates.Iterator_HasNext() )
    267     {
    268         Delegate &dg = *delegates.Iterator_GetNext();
    269         RefleshDelegateParameterAndReturnType( dg );
    270     }
    271 }
     259    foreach (auto *pDelegate, delegates)
     260    {
     261        RefleshDelegateParameterAndReturnType(*pDelegate);
     262    }
     263}

  • trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Procedure.cpp

    r750 r828  
    913913
    914914        if( source[i] == 1 && source[i+1] == ESC_NAMESPACE ){
    915             for(i+=2,i2=0;;i2++,i++){
    916                 if( IsCommandDelimitation( source[i] ) ){
    917                     temporary[i2]=0;
    918                     break;
    919                 }
    920                 temporary[i2]=source[i];
    921             }
    922             namespaceScopes.push_back( temporary );
     915            i+=2;
     916            char const* p = &source[i];
     917            while (!IsCommandDelimitation(source[i]))
     918            {
     919                ++i;
     920            }
     921            namespaceScopes.push_back(std::string(p, &source[i]));
    923922
    924923            continue;
    … …  
    936935        }
    937936        else if( source[i] == 1 && source[i+1] == ESC_IMPORTS ){
    938             for(i+=2,i2=0;;i2++,i++){
    939                 if( IsCommandDelimitation( source[i] ) ){
    940                     temporary[i2]=0;
    941                     break;
    942                 }
    943                 temporary[i2]=source[i];
    944             }
    945             if( !compiler.GetNamespaceSupporter().ImportsNamespace( temporary ) )
    946             {
    947                 compiler.errorMessenger.Output(64,temporary,cp );
     937            i+=2;
     938            char const* p = &source[i];
     939            while (!IsCommandDelimitation(source[i]))
     940            {
     941                ++i;
     942            }
     943            std::string s(p, &source[i]);
     944            if (!compiler.GetNamespaceSupporter().ImportsNamespace(s))
     945            {
     946                compiler.errorMessenger.Output(64, s.c_str(), i);
    948947            }
    949948

  • trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_TypeDef.cpp

    r668 r828  
    11#include "stdafx.h"
     2#include <abdev/ab_common/include/ab_common.h>
     3#include "LexicalAnalyzer.h"
     4#include "Compiler.h"
     5#include "StrOperation.h"
     6#include <boost/algorithm/string/predicate.hpp>
    27
    38using namespace ActiveBasic::Compiler;
    49
    5 void LexicalAnalyzer::AddTypeDef( TypeDefCollection &typeDefs, const NamespaceScopes &namespaceScopes, const std::string &expression, int nowLine )
     10void LexicalAnalyzer::AddTypeDef( TypeDefCollection &typeDefs, const NamespaceScopes &namespaceScopes, const boost::iterator_range<char const*> &expression, int nowLine )
    611{
    7     int i;
    8     char temporary[VN_SIZE];
     12    auto name = boost::find<boost::return_begin_found>(expression, '=');
    913
    10     for(i=0;;i++){
    11         if(expression[i]=='='||expression[i]=='\0'){
    12             temporary[i]=0;
    13             break;
    14         }
    15         temporary[i]=expression[i];
    16     }
    17 
    18     if(expression[i]!='='){
    19         compiler.errorMessenger.Output(10,"TypeDef",nowLine);
     14    if (boost::end(name) == boost::end(expression))
     15    {
     16        compiler.errorMessenger.Output(10, "TypeDef", nowLine);
    2017        return;
    2118    }
    2219
    23     const char *pTemp=expression.c_str()+i+1;
     20    const char *pTemp = expression.begin() + boost::size(name) + 1;
    2421
    2522    //識別文字のエラーチェック（新しい型）
    26     i=0;
    27     for(;;i++){
    28         if(temporary[i]=='\0') break;
    29         if( !( IsVariableChar( temporary[i], true) ) ){
    30             compiler.errorMessenger.Output(10,"TypeDef",nowLine);
    31             return;
    32         }
     23    if (!boost::algorithm::all(name, [](char c) {return IsVariableChar(c, true);}))
     24    {
     25        compiler.errorMessenger.Output(10, "TypeDef", nowLine);
     26        return;
    3327    }
    3428
    … …  
    4135        }
    4236    }
    43     else{
    44         i=0;
     37    else
     38    {
     39        int i=0;
    4540        while(pTemp[i]=='*') i++;
    46         for(;;i++){
    47             if(pTemp[i]=='\0') break;
    48             if( !( IsVariableChar( pTemp[i], true) ) )
    49             {
    50                 compiler.errorMessenger.Output(10,"TypeDef",nowLine);
    51                 return;
    52             }
     41        if (!boost::algorithm::all(name, [](char c) {return IsVariableChar(c, true);}))
     42        {
     43            compiler.errorMessenger.Output(10,"TypeDef",nowLine);
     44            return;
    5345        }
    5446    }
    5547
     48    std::string baseName(pTemp, expression.end());
     49
    5650    //識別子が重複している場合はエラーにする
    57     if(lstrcmp(temporary,pTemp)==0){
     51    if (boost::algorithm::equals(name, baseName))
     52    {
    5853        compiler.errorMessenger.Output(1,NULL,nowLine);
    5954        return;
    … …  
    6762
    6863    Type baseType;
    69     if( !compiler.StringToType( pTemp, baseType ) )
     64    if( !compiler.StringToType( baseName, baseType ) )
    7065    {
    71         compiler.errorMessenger.Output(3, pTemp, nowLine );
     66        compiler.errorMessenger.Output(3, baseName, nowLine );
    7267        return;
    7368    }
    … …  
    7570    typeDefs.push_back(
    7671        TypeDef(
    77             Symbol( namespaceScopes, temporary ),
    78             pTemp,
     72            Symbol(namespaceScopes, boost::copy_range<std::string>(name)),
     73            baseName,
    7974            baseType
    8075        )
    … …  
    9085    compiler.GetNamespaceSupporter().ClearImportedNamespaces();
    9186
    92     int i=-1, i2;
    93     char temporary[VN_SIZE];
    94     while(1){
    95 
    96         i++;
    97 
     87    for (int i = 0; ; ++i)
     88    {
    9889        if( source[i] == 1 && source[i+1] == ESC_NAMESPACE ){
    99             for(i+=2,i2=0;;i2++,i++){
    100                 if( IsCommandDelimitation( source[i] ) ){
    101                     temporary[i2]=0;
    102                     break;
    103                 }
    104                 temporary[i2]=source[i];
     90            i+=2;
     91            char const* p = &source[i];
     92            while (!IsCommandDelimitation(source[i]))
     93            {
     94                ++i;
    10595            }
    106             namespaceScopes.push_back( temporary );
     96            namespaceScopes.push_back(std::string(p, &source[i]));
    10797
    10898            continue;
    … …  
    120110        }
    121111        else if( source[i] == 1 && source[i+1] == ESC_IMPORTS ){
    122             for(i+=2,i2=0;;i2++,i++){
    123                 if( IsCommandDelimitation( source[i] ) ){
    124                     temporary[i2]=0;
    125                     break;
    126                 }
    127                 temporary[i2]=source[i];
     112            i+=2;
     113            char const* p = &source[i];
     114            while (!IsCommandDelimitation(source[i]))
     115            {
     116                ++i;
    128117            }
    129             if( !compiler.GetNamespaceSupporter().ImportsNamespace( temporary ) )
     118            std::string s(p, &source[i]);
     119            if (!compiler.GetNamespaceSupporter().ImportsNamespace(s))
    130120            {
    131                 compiler.errorMessenger.Output(64,temporary,i );
     121                compiler.errorMessenger.Output(64, s.c_str(), i);
    132122            }
    133123
    … …  
    144134            char temporary[VN_SIZE];
    145135            if(source[i+1]==ESC_TYPEDEF){
    146                 int i2 = 0;
    147                 for(i+=2;;i2++,i++){
    148                     if(source[i]=='\n'){
    149                         temporary[i2]=0;
    150                         break;
    151                     }
    152                     temporary[i2]=source[i];
    153                     if(source[i]=='\0') break;
     136                i+=2;
     137                char const* p = &source[i];
     138                while (!IsCommandDelimitation(source[i]))
     139                {
     140                    ++i;
    154141                }
    155                 AddTypeDef( typeDefs, namespaceScopes, temporary, i );
    156 
     142                AddTypeDef(typeDefs, namespaceScopes, boost::make_iterator_range(p, &source[i]), i);
    157143                continue;
    158144            }
    … …  
    168154                }
    169155
    170                 Type baseType;
    171                 if( !compiler.StringToType( "Long", baseType ) )
    172                 {
    173                     throw;
    174                 }
    175 
    176156                typeDefs.push_back(
    177157                    TypeDef(
    178158                        Symbol( namespaceScopes, temporary ),
    179159                        "Long",
    180                         baseType
     160                        Type(DEF_LONG)
    181161                    )
    182162                );

  • trunk/ab5.0/abdev/BasicCompiler_Common/src/Linker.cpp

    r750 r828  
    257257    nativeCode.PutEx( masterObjectModule.globalNativeCode );
    258258
    259     masterObjectModule.meta.GetUserProcs().Iterator_Reset();
    260     while( masterObjectModule.meta.GetUserProcs().Iterator_HasNext() )
    261     {
    262         const UserProc *pUserProc = masterObjectModule.meta.GetUserProcs().Iterator_GetNext();
    263 
     259    foreach (auto pUserProc, masterObjectModule.meta.GetUserProcs())
     260    {
    264261        if( pUserProc->GetNativeCode().GetSize() > 0 )
    265262        {

  • trunk/ab5.0/abdev/BasicCompiler_Common/src/ProcedureGenerator.cpp

    r750 r828  
    1818    int back_cp=cp;
    1919
    20     classes.Iterator_Reset();
    21     while(classes.Iterator_HasNext()){
    22         CClass &objClass = *classes.Iterator_GetNext();
     20    foreach(auto pClass, classes)
     21    {
     22        CClass &objClass = *pClass;
    2323        if( objClass.IsExternal() )
    2424        {
    … …  
    8383    ////////////////////////////////////////////////////////////////////
    8484
    85     // イテレータをリセット
    86     classes.Iterator_Reset();
    87 
    88     while( classes.Iterator_HasNext() ){
    89         const CClass &objClass = *classes.Iterator_GetNext();
     85    foreach (auto pClass, classes)
     86    {
     87        const CClass &objClass = *pClass;
    9088
    9189        if( !objClass.IsUsing() ){
    … …  
    152150    ChangeOpcode( temporary );
    153151
    154     // イテレータをリセット
    155     classes.Iterator_Reset();
    156 
    157     while( classes.Iterator_HasNext() ){
    158         const CClass &objClass = *classes.Iterator_GetNext();
     152    foreach (auto pClass, classes)
     153    {
     154        const CClass &objClass = *pClass;
    159155
    160156        if( !objClass.IsUsing() ){

  • trunk/ab5.0/abdev/BasicCompiler_Common/src/VtblGenerator.cpp

    r750 r828  
    9393void VtblGenerator::GenerateVTablesForAllClasses( Classes &classes )
    9494{
    95     classes.Iterator_Reset();
    96     while( classes.Iterator_HasNext() )
     95    foreach (auto pClass, classes)
    9796    {
    98         CClass *pClass = classes.Iterator_GetNext();
    9997        GenerateFullVTables( *pClass );
    10098
    … …  
    177175void VtblGenerator::ActionVtblScheduleForAllClasses( Classes &classes, LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection, LONG_PTR MemPos_DataSection )
    178176{
    179     classes.Iterator_Reset();
    180     while( classes.Iterator_HasNext() )
     177    foreach(auto pClass, classes)
    181178    {
    182         CClass *pClass = classes.Iterator_GetNext();
    183179        ActionVtblSchedule( *pClass, ImageBase, MemPos_CodeSection, MemPos_DataSection );
    184180
Note: See TracChangeset for help on using the changeset viewer.