Changeset 750 in dev


Ignore:
Timestamp:
Sep 24, 2008, 2:02:16 AM (15 years ago)
Author:
イグトランス (egtra)
Message:

BOOST_FOREACHを可能なものはVC++ 2005 for eachへ置換(やや速くなる)。

Location:
trunk/ab5.0/abdev
Files:
52 edited

Legend:

Unmodified
Added
Removed
  • trunk/ab5.0/abdev/BasicCompiler_Common/BasicCompiler.cpp

    r719 r750  
    11#include "stdafx.h"
     2#include <process.h>
     3#include <fcntl.h>
     4#include <io.h>
    25
    36#include <ver.h>
  • trunk/ab5.0/abdev/BasicCompiler_Common/Debug.cpp

    r743 r750  
    6161
    6262    extern BasicSources sourcesLinkRelationalObjectModule;
    63     BOOST_FOREACH( const BasicSource &source, sourcesLinkRelationalObjectModule )
     63    foreach( const BasicSource &source, sourcesLinkRelationalObjectModule )
    6464    {
    6565        pIncludedFilesRelation = &source.GetIncludedFilesRelation();
     
    347347void Set_DebugSys_dwThreadID()
    348348{
    349     BOOST_FOREACH( DebugSection *pDebugSection, debugSectionCollection.debugSections )
     349    foreach( DebugSection *pDebugSection, debugSectionCollection.debugSections )
    350350    {
    351351        ULONG_PTR lpAccBytes;
  • trunk/ab5.0/abdev/BasicCompiler_Common/DebugMiddleFile.cpp

    r743 r750  
    104104        // オブジェクトモジュールリストに類似したソースコードリストを作成
    105105        BasicSources sources;
    106         BOOST_FOREACH( const ObjectModule *pObjectModule, compiler.staticLibraries )
     106        foreach( const ObjectModule *pObjectModule, compiler.staticLibraries )
    107107        {
    108108            sources.push_back( pObjectModule->GetSource() );
     
    138138    *(long *)(buffer+i2)=(long)sourceLines.size();
    139139    i2+=sizeof(long);
    140     BOOST_FOREACH( const SourceLine &sourceLine, sourceLines )
     140    foreach( const SourceLine &sourceLine, sourceLines )
    141141    {
    142142        *(long *)(buffer+i2) = sourceLine.GetNativeCodePos();
     
    173173    memcpy(buffer,OpBuffer,SizeOf_CodeSection);
    174174
    175     BOOST_FOREACH( const SourceLine &sourceLine, _oldSourceLines )
     175    foreach( const SourceLine &sourceLine, _oldSourceLines )
    176176    {
    177177        if(!(
     
    433433DebugSectionCollection::~DebugSectionCollection()
    434434{
    435     BOOST_FOREACH( DebugSection *pDebugSection, debugSections )
     435    foreach( DebugSection *pDebugSection, debugSections )
    436436    {
    437437        delete pDebugSection;
  • trunk/ab5.0/abdev/BasicCompiler_Common/Diagnose.cpp

    r527 r750  
    7474
    7575            // 動的メソッド
    76             BOOST_FOREACH( const CMethod *pMethod, objClass.GetDynamicMethods() ){
     76            foreach( const CMethod *pMethod, objClass.GetDynamicMethods() ){
    7777                if( pMethod->GetUserProc().IsCompiled() ){
    7878                    codeSizeOfClass += pMethod->GetUserProc().GetCodeSize();
     
    8181
    8282            // 静的メソッド
    83             BOOST_FOREACH( const CMethod *pMethod, objClass.GetStaticMethods() ){
     83            foreach( const CMethod *pMethod, objClass.GetStaticMethods() ){
    8484                    codeSizeOfClass += pMethod->GetUserProc().GetCodeSize();
    8585            }
     
    108108
    109109            // 動的メソッド
    110             BOOST_FOREACH( const CMethod *pMethod, objClass.GetDynamicMethods() ){
     110            foreach( const CMethod *pMethod, objClass.GetDynamicMethods() ){
    111111                if( pMethod->GetUserProc().IsCompiled() ){
    112112                    codeSizeOfClass += pMethod->GetUserProc().GetCodeSize();
     
    115115
    116116            // 静的メソッド
    117             BOOST_FOREACH( const CMethod *pMethod, objClass.GetStaticMethods() ){
     117            foreach( const CMethod *pMethod, objClass.GetStaticMethods() ){
    118118                    codeSizeOfClass += pMethod->GetUserProc().GetCodeSize();
    119119            }
  • trunk/ab5.0/abdev/BasicCompiler_Common/MakeExe.cpp

    r734 r750  
    222222        ActiveBasic::Common::Environment::SetRemoveExternalMark( true );
    223223
    224         BOOST_FOREACH( const std::string &filePath, compiler.staticLibraryFilePaths )
     224        foreach( const std::string &filePath, compiler.staticLibraryFilePaths )
    225225        {
    226226            Jenga::Common::Path path( filePath );
  • trunk/ab5.0/abdev/BasicCompiler_Common/PESchedule.cpp

    r485 r750  
    119119    NowPageRVAToReloc=0;
    120120
    121     BOOST_FOREACH( DWORD addr, codeSectionAddresses )
     121    foreach( DWORD addr, codeSectionAddresses )
    122122    {
    123123        extern int MemPos_CodeSection;
     
    125125    }
    126126
    127     BOOST_FOREACH( DWORD addr, dataSectionAddresses )
     127    foreach( DWORD addr, dataSectionAddresses )
    128128    {
    129129        extern int MemPos_DataSection;
  • trunk/ab5.0/abdev/BasicCompiler_Common/ParamImpl.cpp

    r708 r750  
    8181{
    8282    ParmsNum = 0;
    83     BOOST_FOREACH( Parameter *pParam, params ){
     83    foreach( Parameter *pParam, params ){
    8484        Parms[ParmsNum]=0;
    8585        ParmsNum++;
     
    219219    for( int level=OVERLOAD_MIN_LEVEL; level<=OVERLOAD_MAX_LEVEL; level++ )
    220220    {
    221         BOOST_FOREACH( const UserProc *pTempUserProc, subs )
     221        foreach( const UserProc *pTempUserProc, subs )
    222222        {
    223223            bool isErrored = false;
     
    260260
    261261    if( !pUserProc ){
    262         BOOST_FOREACH( const UserProc *pTempUserProc, subs )
     262        foreach( const UserProc *pTempUserProc, subs )
    263263        {
    264264            //エラーチェック
  • trunk/ab5.0/abdev/BasicCompiler_Common/RSrcSection.cpp

    r624 r750  
    9696
    9797    //カーソルの枚数を計算(CursorNumに格納)
    98     BOOST_FOREACH( const ActiveBasic::Common::ResourceItem &resourceItem, compiler.resourceManager.cursorResources )
     98    foreach( const ActiveBasic::Common::ResourceItem &resourceItem, compiler.resourceManager.cursorResources )
    9999    {
    100100        hFile=CreateFile(resourceItem.filepath.c_str(),GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
     
    116116
    117117    //ビットマップのファイルの有無を確認
    118     BOOST_FOREACH( const ActiveBasic::Common::ResourceItem &resourceItem, compiler.resourceManager.bitmapResources )
     118    foreach( const ActiveBasic::Common::ResourceItem &resourceItem, compiler.resourceManager.bitmapResources )
    119119    {
    120120        hFile=CreateFile(resourceItem.filepath.c_str(),GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
     
    128128
    129129    //アイコンの枚数を計算(IconNumに格納)
    130     BOOST_FOREACH( const ActiveBasic::Common::ResourceItem &resourceItem, compiler.resourceManager.iconResources )
     130    foreach( const ActiveBasic::Common::ResourceItem &resourceItem, compiler.resourceManager.iconResources )
    131131    {
    132132        hFile=CreateFile(resourceItem.filepath.c_str(),GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
  • trunk/ab5.0/abdev/BasicCompiler_Common/VarList.cpp

    r748 r750  
    223223    tv.item.pszText=VarData;
    224224
    225     BOOST_FOREACH( Member *pMember, objClass.GetDynamicMembers() ){
     225    foreach( Member *pMember, objClass.GetDynamicMembers() ){
    226226        if(bPtr){
    227227            lstrcpy(VarName,"->");
     
    327327    extern int MemPos_RWSection;
    328328
    329     BOOST_FOREACH( Variable *pVar, compiler.GetObjectModule().meta.GetGlobalVars() ){
     329    foreach( Variable *pVar, compiler.GetObjectModule().meta.GetGlobalVars() ){
    330330
    331331        //スコープ外の場合は無視
     
    421421    if(!pUserProc) return;
    422422
    423     BOOST_FOREACH( Variable *pVar, pUserProc->GetLocalVars() ){
     423    foreach( Variable *pVar, pUserProc->GetLocalVars() ){
    424424
    425425        //スコープ外の場合は無視
     
    507507    }
    508508
    509     BOOST_FOREACH( Member *pMember, pUserProc->GetParentClassPtr()->GetDynamicMembers() ){
     509    foreach( Member *pMember, pUserProc->GetParentClassPtr()->GetDynamicMembers() ){
    510510        offset=pUserProc->GetParentClassPtr()->GetMemberOffset( pMember->GetName().c_str());
    511511
  • trunk/ab5.0/abdev/BasicCompiler_Common/VariableOpe.cpp

    r721 r750  
    182182    extern WithInfos withInfos;
    183183    buffer[0]=0;
    184     BOOST_FOREACH( const WithInfo &withInfo, withInfos )
     184    foreach( const WithInfo &withInfo, withInfos )
    185185    {
    186186        lstrcat( buffer, withInfo.name.c_str() );
     
    192192    std::string tmp;
    193193    tmp.reserve(1024);
    194     BOOST_FOREACH( const WithInfo &withInfo, withInfos )
     194    foreach( const WithInfo &withInfo, withInfos )
    195195    {
    196196        tmp+=withInfo.name;
  • trunk/ab5.0/abdev/BasicCompiler_Common/WatchList.cpp

    r561 r750  
    326326    UserProc *pUserProc = GetSubFromObp(obp_Rip);
    327327
    328     BOOST_FOREACH( Variable *pVar, pUserProc->GetLocalVars() ){
     328    foreach( Variable *pVar, pUserProc->GetLocalVars() ){
    329329        if( pVar->GetName() == "_System_LocalThis" ){
    330330            return pVar->GetOffsetAddress();
  • trunk/ab5.0/abdev/BasicCompiler_Common/include/Enum.h

    r547 r750  
    4848    const EnumMember &GetEnumMember( const std::string &memberName ) const
    4949    {
    50         BOOST_FOREACH( const EnumMember &member, members )
     50        foreach( const EnumMember &member, members )
    5151        {
    5252            if( member.GetName() == memberName )
     
    7171    {
    7272        const EnumInfoCollection &thisEnumInfoCollection = *this;
    73         BOOST_FOREACH( const EnumInfo &enumInfo, thisEnumInfoCollection )
     73        foreach( const EnumInfo &enumInfo, thisEnumInfoCollection )
    7474        {
    7575            if( enumInfo.IsEqualSymbol( symbol ) )
  • trunk/ab5.0/abdev/BasicCompiler_Common/src/BreakPoint.cpp

    r743 r750  
    3737
    3838    extern BasicSources sourcesLinkRelationalObjectModule;
    39     BOOST_FOREACH( const BasicSource &source, sourcesLinkRelationalObjectModule )
     39    foreach( const BasicSource &source, sourcesLinkRelationalObjectModule )
    4040    {
    4141        pIncludedFilesRelation = &source.GetIncludedFilesRelation();
  • trunk/ab5.0/abdev/BasicCompiler_Common/src/CommonCodeGenerator.cpp

    r551 r750  
    2828void CodeGenerator::ResolveExitSubSchedule()
    2929{
    30     BOOST_FOREACH( long exitSubCodePosition, exitSubCodePositions )
     30    foreach( long exitSubCodePosition, exitSubCodePositions )
    3131    {
    3232        pNativeCode->Overwrite( exitSubCodePosition, (long)( pNativeCode->GetSize()-(exitSubCodePosition+sizeof(long)) ) );
  • trunk/ab5.0/abdev/BasicCompiler_Common/src/Compiler.cpp

    r745 r750  
    2424Compiler::~Compiler()
    2525{
    26     BOOST_FOREACH( ObjectModule *pStaticLibrary, staticLibraries )
     26    foreach( ObjectModule *pStaticLibrary, staticLibraries )
    2727    {
    2828        delete pStaticLibrary;
     
    3333void Compiler::PreStaticLink( const ObjectModules &staticLibraries )
    3434{
    35     BOOST_FOREACH( const ObjectModule *pStaticLibrary, staticLibraries )
     35    foreach( const ObjectModule *pStaticLibrary, staticLibraries )
    3636    {
    3737        // 関連オブジェクトモジュールの名前リスト
     
    4141void Compiler::StaticLink( ObjectModules &staticLibraries )
    4242{
    43     BOOST_FOREACH( ObjectModule *pStaticLibrary, staticLibraries )
     43    foreach( ObjectModule *pStaticLibrary, staticLibraries )
    4444    {
    4545        if( &this->GetObjectModule() == pStaticLibrary )
     
    160160        // 仮型パラメータを実型パラメータに変換
    161161        Types actualTypes;
    162         BOOST_FOREACH( const GenericType &genericType, genericTypes )
     162        foreach( const GenericType &genericType, genericTypes )
    163163        {
    164164            actualTypes.push_back( genericType.GetType() );
     
    378378                // テンプレート展開済みのクラスの場合
    379379                std::string actualGenericTypesName;
    380                 BOOST_FOREACH( const Type &typeParameter, type.GetClass().expandedClassActualTypeParameters )
     380                foreach( const Type &typeParameter, type.GetClass().expandedClassActualTypeParameters )
    381381                {
    382382                    if( actualGenericTypesName.size() )
  • trunk/ab5.0/abdev/BasicCompiler_Common/src/DataTableGenerator.cpp

    r745 r750  
    2828    //dataTable.schedules.push_back( Schedule( Schedule::TypeInfo, &objClass, dataTableOffset + offsetForTypeInfo ) );
    2929
    30     BOOST_FOREACH( const std::string &initMemberValue, initMemberValues )
     30    foreach( const std::string &initMemberValue, initMemberValues )
    3131    {
    3232        int i = 0;
     
    207207    bool isSuccessful = true;
    208208    int i = 0;
    209     BOOST_FOREACH( const std::string &paramStr, parameters )
     209    foreach( const std::string &paramStr, parameters )
    210210    {
    211211        if( paramStr.size() == 0 )
  • trunk/ab5.0/abdev/BasicCompiler_Common/src/Exception.cpp

    r745 r750  
    5050    void ResolveJmpFinally()
    5151    {
    52         BOOST_FOREACH( const PertialSchedule *pPertialSchedule, finallySchedules )
     52        foreach( const PertialSchedule *pPertialSchedule, finallySchedules )
    5353        {
    5454            compiler.codeGenerator.opfix_JmpPertialSchedule( pPertialSchedule );
     
    192192
    193193        int pos = 0;
    194         BOOST_FOREACH( const CatchScope &catchScope, catchScopes )
     194        foreach( const CatchScope &catchScope, catchScopes )
    195195        {
    196196            // パラメータのクラス名
     
    214214
    215215        pos = 0;
    216         BOOST_FOREACH( const CatchScope &catchScope, catchScopes )
     216        foreach( const CatchScope &catchScope, catchScopes )
    217217        {
    218218            // パラメータのクラス名
  • trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Class.cpp

    r732 r750  
    208208
    209209    bool result = true;
    210     BOOST_FOREACH( Member *pMember, objClass.GetDynamicMembers() ){
     210    foreach( Member *pMember, objClass.GetDynamicMembers() ){
    211211        if(pMember->GetType().IsStruct()){
    212212            //循環参照でないかをチェック
     
    332332
    333333    //メソッド
    334     BOOST_FOREACH( const CMethod *pMethod, pobj_c->GetDynamicMethods() )
     334    foreach( const CMethod *pMethod, pobj_c->GetDynamicMethods() )
    335335    {
    336336        //基底クラスと重複する場合はオーバーライドを行う
     
    363363    {
    364364        // インターフェイス メソッドのオーバーライド
    365         BOOST_FOREACH( ::Interface *pInterface, pobj_c->GetInterfaces() )
     365        foreach( ::Interface *pInterface, pobj_c->GetInterfaces() )
    366366        {
    367367            if( interfaceName[0] )
     
    438438        // 型パラメータ文字列から型データを取得
    439439        Types actualTypeParameters;
    440         BOOST_FOREACH( const std::string &typeParameterStr, typeParameterStrings )
     440        foreach( const std::string &typeParameterStr, typeParameterStrings )
    441441        {
    442442            Type type;
     
    517517{
    518518    // まずは継承されたインターフェイスを実装する
    519     BOOST_FOREACH( ::Interface *pInheritsInterface, pInterface->GetClass().GetInterfaces() )
     519    foreach( ::Interface *pInheritsInterface, pInterface->GetClass().GetInterfaces() )
    520520    {
    521521        // TODO: actualTypeParametersの引渡し
     
    532532    // 基底クラスのメソッドからインターフェイスメソッドを再実装する
    533533    /////////////////////////////////////////////////////////////////
    534     BOOST_FOREACH( CMethod *pMethod, _class.GetDynamicMethods() )
     534    foreach( CMethod *pMethod, _class.GetDynamicMethods() )
    535535    {
    536536        DynamicMethod *pMethodForOverride = pInterface->GetDynamicMethods().FindForOverride( pInterface->GetActualTypeParameters(), &pMethod->GetUserProc() );
     
    612612    SplitParameter( interfaceNames, paramStrs );
    613613   
    614     BOOST_FOREACH( const std::string &paramStr, paramStrs )
     614    foreach( const std::string &paramStr, paramStrs )
    615615    {
    616616        char className[VN_SIZE];
     
    619619
    620620        Types actualTypeParameters;
    621         BOOST_FOREACH( const std::string &typeParameterStr, typeParameterStrings )
     621        foreach( const std::string &typeParameterStr, typeParameterStrings )
    622622        {
    623623            Type type;
     
    821821                // 型パラメータ文字列から型データを取得
    822822                Types actualTypeParameters;
    823                 BOOST_FOREACH( const std::string &typeParameterStr, typeParameterStrings )
     823                foreach( const std::string &typeParameterStr, typeParameterStrings )
    824824                {
    825825                    Type type;
     
    13891389
    13901390    // パラメータのジェネリック型を解決
    1391     BOOST_FOREACH( const Parameter *pParam, pBaseMethod->GetUserProc().Params() )
     1391    foreach( const Parameter *pParam, pBaseMethod->GetUserProc().Params() )
    13921392    {
    13931393        Type type = pParam->IsTypeParameter()
     
    13981398        pUserProc->GetParameters().push_back( new Parameter( *pParam, type ) );
    13991399    }
    1400     BOOST_FOREACH( const Parameter *pParam, pBaseMethod->GetUserProc().RealParams() )
     1400    foreach( const Parameter *pParam, pBaseMethod->GetUserProc().RealParams() )
    14011401    {
    14021402        Type type = pParam->IsTypeParameter()
     
    14401440    // 実型パラメータに値型が含まれないとき
    14411441    bool isValueType = false;
    1442     BOOST_FOREACH( const Type &actualType, actualTypes )
     1442    foreach( const Type &actualType, actualTypes )
    14431443    {
    14441444        if( actualType.IsValueType() )
     
    14531453
    14541454    // 展開済みのクラスがあればそれを返す
    1455     BOOST_FOREACH( const ExpandedTemplateClass *pExpandedTemplateClass, _class.expandedTemplateClasses )
     1455    foreach( const ExpandedTemplateClass *pExpandedTemplateClass, _class.expandedTemplateClasses )
    14561456    {
    14571457        if( pExpandedTemplateClass->GetActualTypes().IsEquals( actualTypes ) )
     
    14871487    {
    14881488        Types expandedSuperClassActualTypes;
    1489         BOOST_FOREACH( const Type &superClassActualType, _class.GetSuperClassActualTypeParameters() )
     1489        foreach( const Type &superClassActualType, _class.GetSuperClassActualTypeParameters() )
    14901490        {
    14911491            expandedSuperClassActualTypes.push_back( TemplateExpand_ResolveType( superClassActualType, actualTypes ) );
     
    14971497
    14981498    // インターフェイスのジェネリック型を解決
    1499     BOOST_FOREACH( const ::Interface *pInterface, _class.GetInterfaces() )
     1499    foreach( const ::Interface *pInterface, _class.GetInterfaces() )
    15001500    {
    15011501        const CClass *pExpandedInterfaceClass = TemplateExpand( *const_cast<CClass *>(&pInterface->GetClass()), actualTypes );
     
    15041504
    15051505        // インターフェイス メソッドのジェネリック型を解決
    1506         BOOST_FOREACH( const CMethod *pMethod, pInterface->GetDynamicMethods() )
     1506        foreach( const CMethod *pMethod, pInterface->GetDynamicMethods() )
    15071507        {
    15081508            if( pMethod->GetUserProc().GetParentClassPtr() == &_class )
     
    15331533
    15341534    // メンバのジェネリック型を解決
    1535     BOOST_FOREACH( const Member *pMember, _class.GetDynamicMembers() )
     1535    foreach( const Member *pMember, _class.GetDynamicMembers() )
    15361536    {
    15371537        Type type = pMember->GetType();
     
    15491549
    15501550    // クラス メソッドのジェネリック型を解決
    1551     BOOST_FOREACH( const CMethod *pMethod, _class.GetDynamicMethods() )
     1551    foreach( const CMethod *pMethod, _class.GetDynamicMethods() )
    15521552    {
    15531553        if( pMethod->GetUserProc().GetParentClassPtr() == &_class )
  • trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Delegate.cpp

    r735 r750  
    144144            std::string namespaceScopesCommandStr;
    145145            std::string endNamespaceScopesCommandStr;
    146             BOOST_FOREACH( const std::string &namespaceStr, dg.GetNamespaceScopes() )
     146            foreach( const std::string &namespaceStr, dg.GetNamespaceScopes() )
    147147            {
    148148                if( namespaceScopesCommandStr.size() )
     
    205205        LexicalAnalyzer::ExtractParameterVarNames( dg.GetParamStr().c_str(), paramVarNames, dg.GetSourceIndex() );
    206206        std::string tempParamStrForCall;
    207         BOOST_FOREACH( const std::string &varName, paramVarNames )
     207        foreach( const std::string &varName, paramVarNames )
    208208        {
    209209            if( !tempParamStrForCall.empty() )
  • trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Enum.cpp

    r715 r750  
    160160    buffer.reserve(65536);
    161161
    162     BOOST_FOREACH( const EnumInfo &enumInfo, enums )
     162    foreach( const EnumInfo &enumInfo, enums )
    163163    {
    164         BOOST_FOREACH( const std::string &namespaceStr, enumInfo.GetNamespaceScopes() ){
     164        foreach( const std::string &namespaceStr, enumInfo.GetNamespaceScopes() ){
    165165            buffer.append("Namespace ").append(namespaceStr) += '\n';
    166166        }
     
    179179        buffer.append("\tEnd Sub\n");
    180180
    181         BOOST_FOREACH( const EnumMember &member, enumInfo.GetMembers() )
     181        foreach( const EnumMember &member, enumInfo.GetMembers() )
    182182        {
    183183            buffer.append("\tStatic ")
     
    190190        buffer.append("End Class\n");
    191191
    192         BOOST_FOREACH( const std::string &namespaceStr, enumInfo.GetNamespaceScopes() ){
     192        foreach( const std::string &namespaceStr, enumInfo.GetNamespaceScopes() ){
    193193            buffer.append("End Namespace\n");
    194194        }
  • trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Procedure.cpp

    r710 r750  
    120120
    121121    //パラメータ
    122     BOOST_FOREACH( const std::string &paramStr, parameterStrings )
     122    foreach( const std::string &paramStr, parameterStrings )
    123123    {
    124124        int i = 0;
     
    384384
    385385    //パラメータをコピー
    386     BOOST_FOREACH( Parameter *pParam, userProc.GetParameters() ){
     386    foreach( Parameter *pParam, userProc.GetParameters() ){
    387387        userProc.RealParams().push_back( new Parameter( *pParam ) );
    388388    }
     
    733733    {
    734734        ::Interface *pTargetInterface = NULL;
    735         BOOST_FOREACH( ::Interface *pInterface, pobj_c->GetInterfaces() )
     735        foreach( ::Interface *pInterface, pobj_c->GetInterfaces() )
    736736        {
    737737            if( pInterface->GetClass().GetName() == interfaceName )
     
    855855
    856856    // パラメータのエラーチェック
    857     BOOST_FOREACH( const Parameter *pParam, pDllProc->Params() ){
     857    foreach( const Parameter *pParam, pDllProc->Params() ){
    858858        if( pParam->IsObject() ){
    859859            compiler.errorMessenger.Output(25,pParam->GetVarName(),nowLine);
  • trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalScope.cpp

    r677 r750  
    2323}
    2424void LexicalScope::RunScheduleOfBreak(){
    25     BOOST_FOREACH( const PertialSchedule *pBreakPertialSchedule, breakPertialSchedules )
     25    foreach( const PertialSchedule *pBreakPertialSchedule, breakPertialSchedules )
    2626    {
    2727        compiler.codeGenerator.opfix_JmpPertialSchedule( pBreakPertialSchedule );
     
    7676
    7777    //使用済みローカル変数の生存チェックを外す
    78     BOOST_FOREACH( Variable *pVar, (*pVars) )
     78    foreach( Variable *pVar, (*pVars) )
    7979    {
    8080        if( pVar->isLiving && pVar->GetScopeLevel() == level )
  • trunk/ab5.0/abdev/BasicCompiler_Common/src/Linker.cpp

    r587 r750  
    77void Linker::ResolveDataTableSchedules( long dataSectionBaseOffset )
    88{
    9     BOOST_FOREACH( const Schedule &schedule, nativeCode.GetSchedules() )
     9    foreach( const Schedule &schedule, nativeCode.GetSchedules() )
    1010    {
    1111        if( schedule.GetType() == Schedule::DataTable )
     
    1818    }
    1919
    20     BOOST_FOREACH( const Schedule &schedule, dataTable.schedules )
     20    foreach( const Schedule &schedule, dataTable.schedules )
    2121    {
    2222        if( schedule.GetType() == Schedule::DataTable )
     
    4040void Linker::ResolveCatchAddressSchedules( long codeSectionBaseOffset )
    4141{
    42     BOOST_FOREACH( const Schedule &schedule, nativeCode.GetSchedules() )
     42    foreach( const Schedule &schedule, nativeCode.GetSchedules() )
    4343    {
    4444        if( schedule.GetType() == Schedule::CatchAddress )
     
    5555    }
    5656
    57     BOOST_FOREACH( const Schedule &schedule, dataTable.schedules )
     57    foreach( const Schedule &schedule, dataTable.schedules )
    5858    {
    5959        if( schedule.GetType() == Schedule::CatchAddress )
     
    8181void Linker::ResolveDllProcSchedules( long codeSectionBaseOffset, long importSectionBaseOffset, long lookupSize, long hintSize )
    8282{
    83     BOOST_FOREACH( const Schedule &schedule, nativeCode.GetSchedules() )
     83    foreach( const Schedule &schedule, nativeCode.GetSchedules() )
    8484    {
    8585        if( schedule.GetType() == Schedule::DllProc )
     
    105105void Linker::ResolveUserProcSchedules( long codeSectionBaseOffset )
    106106{
    107     BOOST_FOREACH( const Schedule &schedule, nativeCode.GetSchedules() )
     107    foreach( const Schedule &schedule, nativeCode.GetSchedules() )
    108108    {
    109109        if( schedule.GetType() == Schedule::UserProc
     
    139139    int allInitVarSize = compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.GetSize();
    140140
    141     BOOST_FOREACH( const Schedule &schedule, nativeCode.GetSchedules() )
     141    foreach( const Schedule &schedule, nativeCode.GetSchedules() )
    142142    {
    143143        if( schedule.GetType() == Schedule::GlobalVar )
     
    163163void Linker::ResolveVtblSchedule( long dataSectionBaseOffset )
    164164{
    165     BOOST_FOREACH( const Schedule &schedule, nativeCode.GetSchedules() )
     165    foreach( const Schedule &schedule, nativeCode.GetSchedules() )
    166166    {
    167167        if( schedule.GetType() == Schedule::ComVtbl )
     
    186186    }
    187187
    188     BOOST_FOREACH( const Schedule &schedule, dataTable.schedules )
     188    foreach( const Schedule &schedule, dataTable.schedules )
    189189    {
    190190        if( schedule.GetType() == Schedule::ComVtbl )
     
    226226void Linker::ResolveTypeInfoSchedule( long dataSectionBaseOffset )
    227227{
    228     BOOST_FOREACH( const Schedule &schedule, dataTable.schedules )
     228    foreach( const Schedule &schedule, dataTable.schedules )
    229229    {
    230230        if( schedule.GetType() == Schedule::TypeInfo )
  • trunk/ab5.0/abdev/BasicCompiler_Common/src/Messenger.cpp

    r719 r750  
    409409{
    410410    int count = 0;
    411     BOOST_FOREACH( const ErrorInfo &errorInfo, errorInfos )
     411    foreach( const ErrorInfo &errorInfo, errorInfos )
    412412    {
    413413        if( !errorInfo.IsWarning() )
     
    425425{
    426426    int count = 0;
    427     BOOST_FOREACH( const ErrorInfo &errorInfo, errorInfos )
     427    foreach( const ErrorInfo &errorInfo, errorInfos )
    428428    {
    429429        if( errorInfo.IsWarning() )
     
    438438{
    439439    const ErrorInfo *pErrorInfo = NULL;
    440     BOOST_FOREACH( const ErrorInfo &errorInfo, errorInfos )
     440    foreach( const ErrorInfo &errorInfo, errorInfos )
    441441    {
    442442        if( errorInfo.GetErrorLineNum() == errorLineNum )
  • trunk/ab5.0/abdev/BasicCompiler_Common/src/ProcedureGenerator.cpp

    r637 r750  
    4747
    4848        int i=0;
    49         BOOST_FOREACH( Member *member, objClass.GetStaticMembers() )
     49        foreach( Member *member, objClass.GetStaticMembers() )
    5050        {
    5151            if( pEnumInfo )
     
    122122    std::string result;
    123123
    124     BOOST_FOREACH( const Member *pMember, _class.GetDynamicMembers() )
     124    foreach( const Member *pMember, _class.GetDynamicMembers() )
    125125    {
    126126        if( result.size() )
  • trunk/ab5.0/abdev/BasicCompiler_Common/src/VtblGenerator.cpp

    r632 r750  
    99    //関数テーブルに値をセット
    1010    int i2 = 0;
    11     BOOST_FOREACH( const CMethod *pMethod, methods )
     11    foreach( const CMethod *pMethod, methods )
    1212    {
    1313        if(pMethod->IsVirtual()){
     
    6666
    6767    // インターフェイスのvtblを生成
    68     BOOST_FOREACH( const ::Interface *pInterface, _class.GetInterfaces() )
     68    foreach( const ::Interface *pInterface, _class.GetInterfaces() )
    6969    {
    7070        int tempVtblOffset = GenerateVTablePart( pInterface->GetDynamicMethods() );
     
    100100
    101101        // テンプレート展開されたクラスも
    102         BOOST_FOREACH( ActiveBasic::Common::Lexical::ExpandedTemplateClass *pExpandedTemplateClass, pClass->expandedTemplateClasses )
     102        foreach( ActiveBasic::Common::Lexical::ExpandedTemplateClass *pExpandedTemplateClass, pClass->expandedTemplateClasses )
    103103        {
    104104            if( !pExpandedTemplateClass->GetClass().expandedTemplateClasses.empty() )
     
    149149
    150150    // インターフェイスのvtbl
    151     BOOST_FOREACH( const ::Interface *pInterface, _class.GetInterfaces() )
     151    foreach( const ::Interface *pInterface, _class.GetInterfaces() )
    152152    {
    153153        LONG_PTR *pVtbl = (LONG_PTR *)((char *)compiler.GetObjectModule().dataTable.GetPtr() + pInterface->GetVtblOffset());
     
    184184
    185185        // テンプレート展開されたクラスも
    186         BOOST_FOREACH( ActiveBasic::Common::Lexical::ExpandedTemplateClass *pExpandedTemplateClass, pClass->expandedTemplateClasses )
     186        foreach( ActiveBasic::Common::Lexical::ExpandedTemplateClass *pExpandedTemplateClass, pClass->expandedTemplateClasses )
    187187        {
    188188            if( !pExpandedTemplateClass->GetClass().expandedTemplateClasses.empty() )
  • trunk/ab5.0/abdev/ab_common/ab_common.vcproj

    r640 r750  
    463463            </File>
    464464            <File
     465                RelativePath=".\include\libs.h"
     466                >
     467            </File>
     468            <File
    465469                RelativePath=".\stdafx.h"
    466470                >
  • trunk/ab5.0/abdev/ab_common/include/Lexical/Class.h

    r728 r750  
    194194    {
    195195        int i = 0;
    196         BOOST_FOREACH( const GenericType &genericType, formalGenericTypes )
     196        foreach( const GenericType &genericType, formalGenericTypes )
    197197        {
    198198            if( genericType.GetName() == name )
     
    206206    bool IsExistFormalGenericTypeParameter( const std::string &name ) const
    207207    {
    208         BOOST_FOREACH( const GenericType &genericType, formalGenericTypes )
     208        foreach( const GenericType &genericType, formalGenericTypes )
    209209        {
    210210            if( genericType.GetName() == name )
  • trunk/ab5.0/abdev/ab_common/include/Lexical/DataTable.h

    r640 r750  
    104104
    105105        // スケジュールを追加
    106         BOOST_FOREACH( const Schedule &schedule, dataTable.schedules )
     106        foreach( const Schedule &schedule, dataTable.schedules )
    107107        {
    108108            this->schedules.push_back(
  • trunk/ab5.0/abdev/ab_common/include/Lexical/Namespace.h

    r737 r750  
    3838
    3939        bool isFirst = true;
    40         BOOST_FOREACH( const std::string &itemStr, me ){
     40        foreach( const std::string &itemStr, me ){
    4141            if( isFirst ){
    4242                isFirst = false;
  • trunk/ab5.0/abdev/ab_common/include/Lexical/Procedure.h

    r702 r750  
    5757    }
    5858    ~Procedure(){
    59         BOOST_FOREACH( Parameter *pParam, params ){
     59        foreach( Parameter *pParam, params ){
    6060            delete pParam;
    6161        }
  • trunk/ab5.0/abdev/ab_common/include/Lexical/Type.h

    r713 r750  
    361361    {
    362362        const BlittableTypes &blittableTypes = *this;
    363         BOOST_FOREACH( const BlittableType &blittableType, blittableTypes ){
     363        foreach( const BlittableType &blittableType, blittableTypes ){
    364364            if( blittableType.GetBasicType().Equals( type ) ){
    365365                return true;
     
    371371    {
    372372        const BlittableTypes &blittableTypes = *this;
    373         BOOST_FOREACH( const BlittableType &blittableType, blittableTypes ){
     373        foreach( const BlittableType &blittableType, blittableTypes ){
    374374            if( blittableType.GetBasicType().Equals( type ) ){
    375375                return blittableType;
     
    384384    {
    385385        const BlittableTypes &blittableTypes = *this;
    386         BOOST_FOREACH( const BlittableType &blittableType, blittableTypes ){
     386        foreach( const BlittableType &blittableType, blittableTypes ){
    387387            if( blittableType.GetBasicType().Equals( type ) ){
    388388                return blittableType.GetClassPtr();
  • trunk/ab5.0/abdev/ab_common/include/ab_common.h

    r640 r750  
    22
    33#define trace_for_serialize( msg )
     4
     5#include "libs.h"
    46
    57#include "BasicFixed.h"
  • trunk/ab5.0/abdev/ab_common/src/Lexical/Class.cpp

    r735 r750  
    9999    // 仮想関数になるメソッドに使用チェックをつける
    100100    const CClass &_class = *this;
    101     BOOST_FOREACH( const CMethod *pMethod, _class.GetDynamicMethods() )
     101    foreach( const CMethod *pMethod, _class.GetDynamicMethods() )
    102102    {
    103103        if( pMethod->IsVirtual() )
     
    108108
    109109    // インターフェイスメソッドに使用チェックをつける
    110     BOOST_FOREACH( const ::Interface *pInterface, _class.GetInterfaces() )
    111     {
    112         BOOST_FOREACH( const CMethod *pMethod, pInterface->GetDynamicMethods() )
     110    foreach( const ::Interface *pInterface, _class.GetInterfaces() )
     111    {
     112        foreach( const CMethod *pMethod, pInterface->GetDynamicMethods() )
    113113        {
    114114            pMethod->GetUserProc().Using();
     
    210210bool CClass::IsInheritsInterface( const CClass *pInterfaceClass ) const
    211211{
    212     BOOST_FOREACH( const ::Interface *pInterface, interfaces ){
     212    foreach( const ::Interface *pInterface, interfaces ){
    213213        if( pInterfaceClass == &pInterface->GetClass() ){
    214214            return true;
     
    223223    const Methods& inheritsClassMethods = inheritsClass.GetDynamicMethods();
    224224    GetDynamicMethods().reserve( inheritsClassMethods.size() );
    225     BOOST_FOREACH( const CMethod *pBaseMethod, inheritsClassMethods ){
     225    foreach( const CMethod *pBaseMethod, inheritsClassMethods ){
    226226        CMethod *pMethod = new DynamicMethod( *pBaseMethod );
    227227
     
    256256    const Interfaces& inheritsClassInterfaces = inheritsClass.GetInterfaces();
    257257    interfaces.reserve( inheritsClassInterfaces.size() );
    258     BOOST_FOREACH( const ::Interface *pInterface, inheritsClassInterfaces )
     258    foreach( const ::Interface *pInterface, inheritsClassInterfaces )
    259259    {
    260260        interfaces.push_back( new ::Interface( *pInterface ) );
     
    298298
    299299    //メソッド
    300     BOOST_FOREACH( const CMethod *pMethod, GetDynamicMethods() ){
     300    foreach( const CMethod *pMethod, GetDynamicMethods() ){
    301301        if(  name == pMethod->GetUserProc().GetName() ){
    302302            return 1;
     
    320320
    321321    // 動的メンバ
    322     BOOST_FOREACH( const Member *pMember, dynamicMembers )
     322    foreach( const Member *pMember, dynamicMembers )
    323323    {
    324324        if( GetName() == pMember->GetName() )
     
    329329
    330330    // 静的メンバ
    331     BOOST_FOREACH( Member *pMember, staticMembers ){
     331    foreach( Member *pMember, staticMembers ){
    332332        if( GetName() == pMember->GetName() ){
    333333            return true;
     
    350350    }
    351351
    352     BOOST_FOREACH( Member *pMember, GetDynamicMembers() )
     352    foreach( Member *pMember, GetDynamicMembers() )
    353353    {
    354354        if( pMember->GetName() == memberName )
     
    366366
    367367    // インターフェイス メソッド
    368     BOOST_FOREACH( ::Interface *pInterface, GetInterfaces() )
     368    foreach( ::Interface *pInterface, GetInterfaces() )
    369369    {
    370370        pInterface->GetDynamicMethods().Enum( methodName, subs );
     
    379379    {
    380380        // インターフェイス メソッド
    381         BOOST_FOREACH( ::Interface *pInterface, GetInterfaces() )
     381        foreach( ::Interface *pInterface, GetInterfaces() )
    382382        {
    383383            result = pInterface->GetDynamicMethods().GetMethodPtr( pUserProc );
     
    446446    }
    447447
    448     BOOST_FOREACH( Member *pMember, dynamicMembers )
     448    foreach( Member *pMember, dynamicMembers )
    449449    {
    450450        const Type& memberType = pMember->GetType();
     
    553553    }
    554554
    555     BOOST_FOREACH( Member *pMember, dynamicMembers )
     555    foreach( Member *pMember, dynamicMembers )
    556556    {
    557557        // メンバサイズ
     
    654654    }
    655655
    656     BOOST_FOREACH( Member *pMember, dynamicMembers )
     656    foreach( Member *pMember, dynamicMembers )
    657657    {
    658658        int tempAlignment = pMember->GetType().GetSize();
     
    678678
    679679    vtblIndex = 0;
    680     BOOST_FOREACH( const CMethod *pMethod, GetDynamicMethods() ){
     680    foreach( const CMethod *pMethod, GetDynamicMethods() ){
    681681        if( &pMethod->GetUserProc() == pUserProc )
    682682        {
     
    690690    }
    691691
    692     BOOST_FOREACH( const ::Interface *pInterface, interfaces )
     692    foreach( const ::Interface *pInterface, interfaces )
    693693    {
    694694        vtblMasterListIndex++;
    695695
    696696        vtblIndex = 0;
    697         BOOST_FOREACH( const CMethod *pMethod, pInterface->GetDynamicMethods() ){
     697        foreach( const CMethod *pMethod, pInterface->GetDynamicMethods() ){
    698698            if( &pMethod->GetUserProc() == pUserProc )
    699699            {
     
    715715    int result = 0;
    716716
    717     BOOST_FOREACH( const ::Interface *pInterface, interfaces )
     717    foreach( const ::Interface *pInterface, interfaces )
    718718    {
    719719        result++;
     
    742742    // 未実装(abstract)の仮想関数を持つ場合はtrueを返す
    743743
    744     BOOST_FOREACH( const CMethod *pMethod, GetDynamicMethods() ){
     744    foreach( const CMethod *pMethod, GetDynamicMethods() ){
    745745        if(pMethod->IsVirtual()){
    746746            if(pMethod->IsAbstract()){
     
    751751
    752752    // インターフェイスのvtbl
    753     BOOST_FOREACH( const ::Interface *pInterface, interfaces )
    754     {
    755         BOOST_FOREACH( const CMethod *pMethod, pInterface->GetDynamicMethods() ){
     753    foreach( const ::Interface *pInterface, interfaces )
     754    {
     755        foreach( const CMethod *pMethod, pInterface->GetDynamicMethods() ){
    756756            if(pMethod->IsVirtual()){
    757757                if(pMethod->IsAbstract()){
     
    791791        pClass = classes.front();
    792792
    793         BOOST_FOREACH( const CClass *pTempClass, classes )
     793        foreach( const CClass *pTempClass, classes )
    794794        {
    795795            if( pClass->GetNamespaceScopes().size() < pTempClass->GetNamespaceScopes().size() )
     
    837837    std::string result;
    838838
    839     BOOST_FOREACH( const Member *pMember, dynamicMembers )
     839    foreach( const Member *pMember, dynamicMembers )
    840840    {
    841841        if( result.size() )
     
    853853    std::string result;
    854854
    855     BOOST_FOREACH( const Member *pMember, dynamicMembers )
     855    foreach( const Member *pMember, dynamicMembers )
    856856    {
    857857        if( result.size() )
     
    874874{
    875875    const CClass &thisClass = *this;
    876     BOOST_FOREACH( const Member *pMember, thisClass.GetDynamicMembers() )
     876    foreach( const Member *pMember, thisClass.GetDynamicMembers() )
    877877    {
    878878        if( pMember->GetType().IsObject() || pMember->GetType().IsPointer() )
     
    935935
    936936    // 実装するインターフェイス
    937     BOOST_FOREACH( ::Interface *pInterface, interfaces )
     937    foreach( ::Interface *pInterface, interfaces )
    938938    {
    939939        pInterface->Resolve( resolver, resolveErrors );
     
    941941
    942942    // 動的メンバ
    943     BOOST_FOREACH( Member *pMember, dynamicMembers )
     943    foreach( Member *pMember, dynamicMembers )
    944944    {
    945945        pMember->Resolve( resolver, resolveErrors );
     
    947947
    948948    // 静的メンバ
    949     BOOST_FOREACH( Member *pMember, staticMembers )
     949    foreach( Member *pMember, staticMembers )
    950950    {
    951951        pMember->Resolve( resolver, resolveErrors );
     
    953953
    954954    // 動的メソッド
    955     BOOST_FOREACH( CMethod *pMethod, GetDynamicMethods() )
     955    foreach( CMethod *pMethod, GetDynamicMethods() )
    956956    {
    957957        pMethod->Resolve( resolver, resolveErrors );
     
    959959
    960960    // 静的メソッド
    961     BOOST_FOREACH( CMethod *pMethod, staticMethods )
     961    foreach( CMethod *pMethod, staticMethods )
    962962    {
    963963        pMethod->Resolve( resolver, resolveErrors );
     
    965965
    966966    // テンプレート展開後のクラス
    967     BOOST_FOREACH( ActiveBasic::Common::Lexical::ExpandedTemplateClass *pExpandedTemplateClass, expandedTemplateClasses )
     967    foreach( ActiveBasic::Common::Lexical::ExpandedTemplateClass *pExpandedTemplateClass, expandedTemplateClasses )
    968968    {
    969969        pExpandedTemplateClass->Resolve( resolver, resolveErrors );
  • trunk/ab5.0/abdev/ab_common/src/Lexical/DataTable.cpp

    r747 r750  
    5959void DataTable::ResetDataSectionBaseOffset( long dataSectionBaseOffset )
    6060{
    61     BOOST_FOREACH( const Schedule &schedule, schedules )
     61    foreach( const Schedule &schedule, schedules )
    6262    {
    6363        if( schedule.GetType() == Schedule::DataTable )
  • trunk/ab5.0/abdev/ab_common/src/Lexical/Delegate.cpp

    r640 r750  
    2323    Procedure::Resolve( resolver, resolveErrors );
    2424
    25     BOOST_FOREACH( Parameter *pParameter, dynamicParams )
     25    foreach( Parameter *pParameter, dynamicParams )
    2626    {
    2727        pParameter->Resolve( resolver, resolveErrors );
  • trunk/ab5.0/abdev/ab_common/src/Lexical/Interface.cpp

    r640 r750  
    88{
    99    //メソッドをコピー
    10     BOOST_FOREACH( const CMethod *pBaseMethod, pInterfaceClass->GetDynamicMethods() )
     10    foreach( const CMethod *pBaseMethod, pInterfaceClass->GetDynamicMethods() )
    1111    {
    1212        CMethod *pMethod = new DynamicMethod( *pBaseMethod );
     
    5757    {
    5858        std::string actualGenericTypesName;
    59         BOOST_FOREACH( const Type &typeParameter, actualTypeParameters )
     59        foreach( const Type &typeParameter, actualTypeParameters )
    6060        {
    6161            if( actualGenericTypesName.size() )
     
    7474{
    7575    // 動的メソッド
    76     BOOST_FOREACH( CMethod *pMethod, GetDynamicMethods() )
     76    foreach( CMethod *pMethod, GetDynamicMethods() )
    7777    {
    7878        pMethod->Resolve( resolver, resolveErrors );
  • trunk/ab5.0/abdev/ab_common/src/Lexical/Meta.cpp

    r640 r750  
    9999    // グローバル変数
    100100    long initAreaBaseOffset = this->globalVars.initAreaBuffer.GetSize();
    101     BOOST_FOREACH( Variable *pVar, meta.globalVars )
     101    foreach( Variable *pVar, meta.globalVars )
    102102    {
    103103        if( pVar->IsExternal() )
     
    186186
    187187    // 関数ポインタ
    188     BOOST_FOREACH( ProcPointer *pProcPointer, meta.procPointers )
     188    foreach( ProcPointer *pProcPointer, meta.procPointers )
    189189    {
    190190        if( pProcPointer->IsExternal() )
     
    283283
    284284    // グローバル変数
    285     BOOST_FOREACH( Variable *pVar, globalVars )
     285    foreach( Variable *pVar, globalVars )
    286286    {
    287287        pVar->Resolve( resolver, resolveErrors );
     
    319319
    320320    // 関数ポインタ
    321     BOOST_FOREACH( ProcPointer *pProcPointer, procPointers )
     321    foreach( ProcPointer *pProcPointer, procPointers )
    322322    {
    323323        pProcPointer->Resolve( resolver, resolveErrors );
  • trunk/ab5.0/abdev/ab_common/src/Lexical/Method.cpp

    r640 r750  
    9292Methods::Methods( const Methods &methods )
    9393{
    94     BOOST_FOREACH( CMethod *pMethod, methods )
     94    foreach( CMethod *pMethod, methods )
    9595    {
    9696        this->push_back( new DynamicMethod( dynamic_cast<DynamicMethod &>(*pMethod) ) );
     
    101101{
    102102    Methods &methods = *this;
    103     BOOST_FOREACH( CMethod *pMethod, methods )
     103    foreach( CMethod *pMethod, methods )
    104104    {
    105105        delete pMethod;
     
    122122    //メソッドのオーバーライド
    123123    Methods &methods = *this;
    124     BOOST_FOREACH( CMethod *pMethod, methods )
     124    foreach( CMethod *pMethod, methods )
    125125    {
    126126        if( !pMethod->IsNotUse() && pMethod->GetUserProc().IsEqualForOverride( actualTypeParametersForThisMethods, pUserProc ) )
     
    145145{
    146146    const Methods &methods = *this;
    147     BOOST_FOREACH( const CMethod *pMethod, methods ){
     147    foreach( const CMethod *pMethod, methods ){
    148148        if( pMethod->GetUserProc().GetName() == name ) return true;
    149149    }
     
    181181    int count = 0;
    182182    const Methods &methods = *this;
    183     BOOST_FOREACH( const CMethod *pMethod, methods )
     183    foreach( const CMethod *pMethod, methods )
    184184    {
    185185        if( pMethod->IsVirtual() )
  • trunk/ab5.0/abdev/ab_common/src/Lexical/NamespaceSupporter.cpp

    r736 r750  
    4747
    4848    // Importsされている名前空間とのマッチングを試みる
    49     BOOST_FOREACH( const NamespaceScopes &importedNamespaceScopes, GetImportedNamespaces() )
     49    foreach( const NamespaceScopes &importedNamespaceScopes, GetImportedNamespaces() )
    5050    {
    5151        if( base.IsEqual( importedNamespaceScopes + entry ) )
  • trunk/ab5.0/abdev/ab_common/src/Lexical/NativeCode.cpp

    r645 r750  
    8484
    8585    // スケジュールを追加
    86     BOOST_FOREACH( const Schedule &schedule, nativeCode.schedules )
     86    foreach( const Schedule &schedule, nativeCode.schedules )
    8787    {
    8888        this->schedules.push_back(
     
    9696
    9797    // ソースコード行番号とネイティブコード位置の対応情報を追加
    98     BOOST_FOREACH( const SourceLine &sourceLine, nativeCode.sourceLines )
     98    foreach( const SourceLine &sourceLine, nativeCode.sourceLines )
    9999    {
    100100        this->sourceLines.push_back(
     
    191191void NativeCode::ResetDataSectionBaseOffset( long dataSectionBaseOffset )
    192192{
    193     BOOST_FOREACH( const Schedule &schedule, schedules )
     193    foreach( const Schedule &schedule, schedules )
    194194    {
    195195        if( schedule.GetType() == Schedule::DataTable )
  • trunk/ab5.0/abdev/ab_common/src/Lexical/ObjectModule.cpp

    r640 r750  
    1111#include <sstream>
    1212
     13#define WIN32_LEAN_AND_MEAN
    1314#include <windows.h>
    1415#include <stdio.h>
    1516#include <string.h>
    1617#include <math.h>
    17 #include <commctrl.h>
    1818#include <time.h>
    1919#include <limits.h>
    2020#include <shlobj.h>
    21 #include <process.h>
    22 #include <fcntl.h>
    23 #include <io.h>
    24 #include <shlwapi.h>
    2521#include <tchar.h>
    26 #include <stdarg.h>
    2722
    2823//boost libraries
     
    5247#include <boost/serialization/export.hpp>
    5348
     49#define foreach(v, c) for each (v in c)
     50
    5451#include <jenga/include/jenga.h>
    5552#include <abdev/ab_common/include/ab_common.h>
     
    9996
    10097    // リレーションテーブルを構築
    101     BOOST_FOREACH( const std::string &oldRelationalObjectModuleName, oldRelationalObjectModuleNames )
     98    foreach( const std::string &oldRelationalObjectModuleName, oldRelationalObjectModuleNames )
    10299    {
    103100        bool isMatch = false;
     
    141138        isSuccessful = true;
    142139    }
    143     catch( boost::archive::archive_exception e )
     140    catch( boost::archive::archive_exception& e )
    144141    {
    145142        MessageBox( NULL, e.what(), "XMLシリアライズの例外", MB_OK );
     
    174171        isSuccessful = true;
    175172    }
    176     catch( boost::archive::archive_exception e )
     173    catch( boost::archive::archive_exception& e )
    177174    {
    178175        MessageBox( NULL, e.what(), "XMLシリアライズの例外", MB_OK );
     
    209206        isSuccessful = true;
    210207    }
    211     catch( boost::archive::archive_exception e )
     208    catch( boost::archive::archive_exception& e )
    212209    {
    213210        MessageBox( NULL, e.what(), "XMLシリアライズの例外", MB_OK );
     
    245242        isSuccessful = true;
    246243    }
    247     catch( boost::archive::archive_exception e )
     244    catch( boost::archive::archive_exception &e )
    248245    {
    249246        MessageBox( NULL, e.what(), "XMLシリアライズの例外", MB_OK );
  • trunk/ab5.0/abdev/ab_common/src/Lexical/Procedure.cpp

    r641 r750  
    1414bool Procedure::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    1515{
    16     BOOST_FOREACH( Parameter *pParameter, params )
     16    foreach( Parameter *pParameter, params )
    1717    {
    1818        pParameter->Resolve( resolver, resolveErrors );
     
    8282UserProc::~UserProc()
    8383{
    84     BOOST_FOREACH( Parameter *pParam, realParams ){
     84    foreach( Parameter *pParam, realParams ){
    8585        delete pParam;
    8686    }
     
    219219    }
    220220
    221     BOOST_FOREACH( Parameter *pParameter, realParams )
     221    foreach( Parameter *pParameter, realParams )
    222222    {
    223223        pParameter->Resolve( resolver, resolveErrors );
    224224    }
    225225
    226     BOOST_FOREACH( Variable *pLocalVar, localVars )
     226    foreach( Variable *pLocalVar, localVars )
    227227    {
    228228        pLocalVar->Resolve( resolver, resolveErrors );
     
    270270{
    271271    ProcPointers &procPointers = *this;
    272     BOOST_FOREACH( ProcPointer *pProcPointer, procPointers ){
     272    foreach( ProcPointer *pProcPointer, procPointers ){
    273273        delete pProcPointer;
    274274    }
  • trunk/ab5.0/abdev/ab_common/src/Lexical/Type.cpp

    r640 r750  
    524524    {
    525525        std::string actualGenericTypesName;
    526         BOOST_FOREACH( const GenericType &actualGenericType, actualGenericTypes )
     526        foreach( const GenericType &actualGenericType, actualGenericTypes )
    527527        {
    528528            if( actualGenericTypesName.size() )
  • trunk/ab5.0/abdev/ab_common/src/Lexical/TypeDef.cpp

    r640 r750  
    2626{
    2727    const TypeDefCollection &typeDefs = *this;
    28     BOOST_FOREACH( const TypeDef &typeDef, typeDefs )
     28    foreach( const TypeDef &typeDef, typeDefs )
    2929    {
    3030        if( typeDef.IsEqualSymbol( symbol ) )
  • trunk/ab5.0/abdev/ab_common/stdafx.h

    r701 r750  
    66#include <fstream>
    77#include <iostream>
     8#include <algorithm>
    89
    910#include <windows.h>
     
    1112#include <string.h>
    1213#include <math.h>
    13 #include <commctrl.h>
    1414#include <time.h>
    1515#include <limits.h>
    1616#include <shlobj.h>
    17 #include <process.h>
    18 #include <fcntl.h>
    19 #include <io.h>
    2017
    2118//boost libraries
     
    2825
    2926#include "include/ab_common.h"
    30 
  • trunk/ab5.0/abdev/compiler_x86/Compile_Object.cpp

    r728 r750  
    111111    {
    112112        std::string tempMessage;
    113         BOOST_FOREACH( const CMethod *pMethod, pClass->GetDynamicMethods() ){
     113        foreach( const CMethod *pMethod, pClass->GetDynamicMethods() ){
    114114            if(pMethod->IsVirtual()){
    115115                if(pMethod->IsAbstract()){
     
    124124
    125125        // インターフェイスのvtbl
    126         BOOST_FOREACH( const ::Interface *pInterface, pClass->GetInterfaces() )
     126        foreach( const ::Interface *pInterface, pClass->GetInterfaces() )
    127127        {
    128             BOOST_FOREACH( const CMethod *pMethod, pInterface->GetDynamicMethods() ){
     128            foreach( const CMethod *pMethod, pInterface->GetDynamicMethods() ){
    129129                if(pMethod->IsVirtual()){
    130130                    if(pMethod->IsAbstract()){
     
    261261
    262262        // 仮想関数になるメソッドに使用チェックをつける
    263         BOOST_FOREACH( const CMethod *pMethod, pClass->GetDynamicMethods() )
     263        foreach( const CMethod *pMethod, pClass->GetDynamicMethods() )
    264264        {
    265265            if( pMethod->IsVirtual() )
     
    268268            }
    269269        }
    270         BOOST_FOREACH( const ::Interface *pInterface, pClass->GetInterfaces() )
     270        foreach( const ::Interface *pInterface, pClass->GetInterfaces() )
    271271        {
    272             BOOST_FOREACH( const CMethod *pMethod, pInterface->GetDynamicMethods() )
     272            foreach( const CMethod *pMethod, pInterface->GetDynamicMethods() )
    273273            {
    274274                if( pMethod->IsVirtual() )
  • trunk/ab5.0/abdev/compiler_x86/Compile_ProcOp.cpp

    r728 r750  
    5656        //静的ローカルオブジェクトのコンストラクタ呼び出し
    5757
    58         BOOST_FOREACH( Variable *pVar, compiler.GetObjectModule().meta.GetGlobalVars() ){
     58        foreach( Variable *pVar, compiler.GetObjectModule().meta.GetGlobalVars() ){
    5959            if(memicmp(pVar->GetName().c_str(),"Static%",7)==0){
    6060                //コンストラクタ呼び出し
     
    225225
    226226        //Goto未知ラベルスケジュールが存在したらエラーにする
    227         BOOST_FOREACH( const GotoLabelSchedule *pGotoLabelSchedule, compiler.codeGenerator.gotoLabelSchedules )
     227        foreach( const GotoLabelSchedule *pGotoLabelSchedule, compiler.codeGenerator.gotoLabelSchedules )
    228228        {
    229229            if(pGotoLabelSchedule->GetName().size()>0){
     
    699699
    700700    //ローカル変数アドレススケジュール
    701     BOOST_FOREACH( const PertialSchedule *pPertialSchedule, compiler.codeGenerator.localVarPertialSchedules )
     701    foreach( const PertialSchedule *pPertialSchedule, compiler.codeGenerator.localVarPertialSchedules )
    702702    {
    703703        compiler.codeGenerator.opfix_offset( pPertialSchedule, AllLocalVarSize );
    704704    }
    705705    compiler.codeGenerator.localVarPertialSchedules.clear();
    706     BOOST_FOREACH( Variable *pVar, pUserProc->GetLocalVars() ){
     706    foreach( Variable *pVar, pUserProc->GetLocalVars() ){
    707707        //後にデバッグで利用する
    708708        pVar->SetOffsetAddress( AllLocalVarSize - pVar->GetOffsetAddress() );
  • trunk/ab5.0/abdev/compiler_x86/Compile_Statement.cpp

    r720 r750  
    289289int GetLabelAddress(char *LabelName,int LineNum){
    290290    if(LabelName){
    291         BOOST_FOREACH( const GotoLabel &label, compiler.codeGenerator.gotoLabels )
     291        foreach( const GotoLabel &label, compiler.codeGenerator.gotoLabels )
    292292        {
    293293            if( label.name.size() > 0 )
     
    301301    }
    302302    else{
    303         BOOST_FOREACH( const GotoLabel &label, compiler.codeGenerator.gotoLabels )
     303        foreach( const GotoLabel &label, compiler.codeGenerator.gotoLabels )
    304304        {
    305305            if( label.name.size() == 0 )
  • trunk/ab5.0/abdev/compiler_x86/Compile_Var.cpp

    r745 r750  
    792792
    793793            int i = 0;
    794             BOOST_FOREACH( Member *pMember, objClass.GetDynamicMembers() ){
     794            foreach( Member *pMember, objClass.GetDynamicMembers() ){
    795795                if(InitBuf[i]=='\0'){
    796796                    compiler.errorMessenger.Output(41,0,cp);
     
    955955
    956956            int i = 0;
    957             BOOST_FOREACH( Member *pMember, objClass.GetDynamicMembers() ){
     957            foreach( Member *pMember, objClass.GetDynamicMembers() ){
    958958                if(InitBuf[i]=='\0'){
    959959                    compiler.errorMessenger.Output(41,0,cp);
     
    13331333    }
    13341334
    1335     BOOST_FOREACH( const Variable *pVar, compiler.GetObjectModule().meta.GetGlobalVars() ){
     1335    foreach( const Variable *pVar, compiler.GetObjectModule().meta.GetGlobalVars() ){
    13361336        if( pVar->GetType().IsObject() || pVar->GetType().IsPointer() || pVar->GetType().IsStruct() ){
    13371337            // オブジェクトまたはポインタだったとき
  • trunk/ab5.0/abdev/compiler_x86/MakePeHdr.cpp

    r749 r750  
    126126    ActiveBasic::Common::Lexical::ResolveErrors resolveErrors;
    127127    compiler.GetObjectModule().Resolve( resolveErrors );
    128     BOOST_FOREACH( const ResolveError &resolveError, resolveErrors )
     128    foreach( const ResolveError &resolveError, resolveErrors )
    129129    {
    130130        compiler.errorMessenger.Output( ErrorInfo( 13, resolveError.GetTargetItemName(), -1 ) );
     
    551551    // 使用するDLL関数のチェック
    552552    ////////////////////////////////
    553     BOOST_FOREACH( const Schedule &schedule, compiler.linker.GetNativeCode().GetSchedules() )
     553    foreach( const Schedule &schedule, compiler.linker.GetNativeCode().GetSchedules() )
    554554    {
    555555        if( schedule.GetType() == Schedule::DllProc )
     
    834834    //グローバル変数情報を扱う構造体も初期バッファの有無による配置を行う
    835835    //(デバッグ情報で利用される)
    836     BOOST_FOREACH( Variable *pVar, compiler.GetObjectModule().meta.GetGlobalVars() ){
     836    foreach( Variable *pVar, compiler.GetObjectModule().meta.GetGlobalVars() ){
    837837        if(pVar->GetOffsetAddress()&0x80000000){
    838838            pVar->SetOffsetAddress(
  • trunk/ab5.0/abdev/compiler_x86/stdafx.h

    r686 r750  
    1010#include <streambuf>
    1111#include <sstream>
     12#include <algorithm>
    1213
    1314#include <windows.h>
     
    1920#include <limits.h>
    2021#include <shlobj.h>
    21 #include <process.h>
    22 #include <fcntl.h>
    23 #include <io.h>
    2422#include <shlwapi.h>
    2523#include <tchar.h>
     
    5856#include <DataTableGenerator.h>
    5957#include <BreakPoint.h>
    60 
    61 #define lstrlenA strlen
    62 #define lstrcmpA strcmp
    63 #define lstrcpyA strcpy
    64 #define lstrcmpiA _stricmp
Note: See TracChangeset for help on using the changeset viewer.