Changeset 569 for trunk


Ignore:
Timestamp:
09/07/08 19:59:53 (11 years ago)
Author:
Eoin
Message:

Proper win32_exception catching in trunk.

Location:
trunk/src
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/Halite.cpp

    r564 r569  
    112112int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) 
    113113{ 
     114        win32_exception::install_handler(); 
     115 
     116        int return_result = -1; 
     117 
    114118        try  
    115119        { 
    116120         
    117121        boost::filesystem::path::default_name_check(boost::filesystem::native); 
    118 //      _set_abort_behavior( 0, _WRITE_ABORT_MSG); 
    119122 
    120123        try 
     
    139142        ATLASSERT(hInstRich != NULL); 
    140143    
    141         int nRet = 0;    
    142144        HRESULT hRes = _Module.Init(NULL, hInstance); 
    143145        assert (SUCCEEDED(hRes));        
     
    206208                        wndMain.ShowWindow(nCmdShow); 
    207209                         
    208                         nRet = theLoop.Run();                            
     210                        return_result = theLoop.Run();                           
    209211                 
    210212                _Module.RemoveMessageLoop(); 
     
    218220        _Module.Term(); 
    219221         
    220         return nRet; 
    221          
    222         } 
    223         catch (const std::exception& e) 
    224         { 
    225         std::cerr << e.what() << " Exception Thrown!" << std::endl;//MessageBoxA(0, e.what(), "Exception Thrown!", 0); 
    226          
    227         return -1; 
    228         }        
    229 } 
     222        } 
     223        catch (const access_violation& e) 
     224        { 
     225                wstring msg = (hal::wform(L"WinMain() access_violation (code %1$x) at %2$x. Bad address %3$x")  
     226                        % e.code() % (unsigned)e.where() % (unsigned)e.badAddress()).str(); 
     227 
     228                MessageBox(0, msg.c_str(), L"Exception Thrown!", 0); 
     229        }  
     230        catch (const win32_exception& e) 
     231        { 
     232                wstring msg = (hal::wform(L"WinMain() win32_exception (code %1$x) at %2$x")  
     233                        % e.code() % (unsigned)e.where()).str(); 
     234 
     235                MessageBox(0, msg.c_str(), L"Exception Thrown!", 0); 
     236        } 
     237        catch (std::exception& e) 
     238        { 
     239                wstring msg = (hal::wform(L"WinMain() std::exception, %1%") % hal::from_utf8(e.what())).str(); 
     240 
     241                MessageBox(0, msg.c_str(), L"Exception Thrown!", 0); 
     242        } 
     243        catch (...) 
     244        { 
     245                MessageBox(0, L"WinMain() catch all", L"Exception Thrown!", 0); 
     246        } 
     247         
     248        return return_result; 
     249} 
  • trunk/src/HaliteDialogBase.hpp

    r507 r569  
    6666        void handleUiUpdate(const hal::torrent_details_manager& tD) 
    6767        { 
     68                try 
     69                { 
     70 
    6871                TBase* pT = static_cast<TBase*>(this); 
    6972                 
     
    7578                        pT->focusChanged(focusedTorrent_ = focused); 
    7679                         
    77                         hal::event_log.post(shared_ptr<hal::EventDetail>( 
    78                                 new hal::EventMsg(L"Adv dialog focusChanged"))); 
     80                        HAL_DEV_MSG(hal::wform(L"HaliteDialogBase::handleUiUpdate(%1%)")  
     81                                % hal::to_wstr_shim(focusedTorrent_->name())); 
    7982                } 
    8083                else 
     
    8285         
    8386                pT->uiUpdate(tD); 
     87 
     88                } HAL_GENERIC_FN_EXCEPTION_CATCH(L"HaliteDialogBase::handleUiUpdate()") 
    8489        } 
    8590 
  • trunk/src/HaliteWindow.cpp

    r564 r569  
    269269        } 
    270270         
    271         } 
    272         catch (std::exception& e) 
    273         { 
    274                 hal::event_log.post(shared_ptr<hal::EventDetail>(\ 
    275                         new hal::EventStdException(hal::event_logger::info, e, L"updateWindow"))); 
    276         } 
     271        } HAL_GENERIC_FN_EXCEPTION_CATCH(L"HaliteWindow::updateWindow()") 
    277272} 
    278273 
     
    291286                hal::bittorrent().save_torrent_data();   
    292287         
    293                 } 
    294                 catch (std::exception& e) 
    295                 { 
    296                         hal::event_log.post(shared_ptr<hal::EventDetail>(\ 
    297                                 new hal::EventStdException(hal::event_logger::info, e, L"saveTimer"))); 
    298                 } 
     288                } HAL_GENERIC_FN_EXCEPTION_CATCH(L"HaliteWindow::OnTimer(ID_SAVE_TIMER)") 
    299289        } 
    300290        else  
     
    314304        ui_update_signal_(torrents); 
    315305 
    316         } 
    317         catch (std::exception& e) 
    318         { 
    319                 hal::event_log.post(shared_ptr<hal::EventDetail>( 
    320                         new hal::EventStdException(hal::event_logger::info, e, L"updateTimer"))); 
    321         } 
     306        } HAL_GENERIC_FN_EXCEPTION_CATCH(L"HaliteWindow::issueUiUpdate()") 
    322307} 
    323308 
     
    404389        { 
    405390 
     391        win32_exception::install_handler(); 
    406392        hal::bittorrent().close_all(0); 
    407393 
     
    411397        hal::bittorrent().shutDownSession(); 
    412398 
    413         } 
    414         catch(std::exception& e) 
    415         { 
    416                 hal::event_log.post(shared_ptr<hal::EventDetail>(\ 
    417                         new hal::EventStdException(hal::event_logger::debug, e, L"ShutdownThread()"))); 
    418         } 
    419         catch(...) 
    420         { 
    421                 hal::event_log.post(shared_ptr<hal::EventDetail>( 
    422                         new hal::EventGeneral(hal::event_logger::warning,  
    423                                 hal::event_logger::unclassified, L"ShutdownThread() catch all"))); 
    424         } 
     399        } HAL_GENERIC_FN_EXCEPTION_CATCH(L"HaliteWindow::ShutdownThread()") 
    425400} 
    426401  
     
    465440        PostQuitMessage(0);      
    466441 
    467         } 
    468         catch(const std::exception& e) 
    469         { 
    470                 hal::event_log.post(shared_ptr<hal::EventDetail>( 
    471                         new hal::EventStdException(hal::event_logger::fatal, e, L"HaliteWindow::OnDestroy()"))); 
    472         }        
     442        } HAL_GENERIC_FN_EXCEPTION_CATCH(L"HaliteWindow::OnDestroy()") 
    473443} 
    474444 
  • trunk/src/SplashDialog.hpp

    r565 r569  
    130130                save_to_ini(); 
    131131 
    132                 } 
    133                 HAL_GENERIC_FN_EXCEPTION_CATCH(L"SplashThread()") 
     132                } HAL_GENERIC_FN_EXCEPTION_CATCH(L"SplashThread()") 
    134133 
    135134                EndDialog(0); 
  • trunk/src/global/txml_iarchive.hpp

    r554 r569  
    202202                if (name) 
    203203                { 
    204                         xml::node* failsafe_current = 0; 
    205  
    206204                        TXML_LOG(boost::wformat(L" << load_start: %1%") % from_utf8(name)); 
    207205 
    208                         node_stack_.push(current_node_); 
    209                         failsafe_current = current_node_; 
     206                        xml::node* failsafe_current = current_node_; 
    210207 
    211208                        boost::filesystem::path location(name); 
     
    263260 
    264261                        previous_child_node_ = current_node_; 
    265  
    266                         current_node_ = node_stack_.top(); 
    267                         node_stack_.pop(); 
    268262                } 
    269263        } 
     
    286280    void load_override(const ::boost::serialization::nvp<T>& t, int) 
    287281        { 
     282                node_stack_.push(current_node_); 
     283 
    288284                if (t.name())  
    289285                { 
     
    298294                else 
    299295                        TXML_LOG(boost::wformat(L" << load_aborted: %1%") % t.name()); 
     296 
     297                current_node_ = node_stack_.top(); 
     298                node_stack_.pop(); 
    300299    } 
    301300 
  • trunk/src/global/txml_ini_adapter.cpp

    r539 r569  
    1818#include "txml.hpp" 
    1919#include "unicode.hpp" 
    20  
    21 #define TXML_ARCHIVE_LOGGING 
    2220 
    2321#ifndef TXML_ARCHIVE_LOGGING 
  • trunk/src/halConfig.cpp

    r542 r569  
    2424bool Config::settingsThread() 
    2525{        
     26        win32_exception::install_handler(); 
     27 
     28        try 
     29        { 
     30 
    2631        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Applying BitTorrent session settings.")));         
    2732 
     
    111116        save_to_ini();   
    112117        return true; 
     118 
     119        } HAL_GENERIC_FN_EXCEPTION_CATCH(L"Config::settingsThread()") 
     120 
     121        return false; 
    113122} 
    114123 
  • trunk/src/halEvent.hpp

    r565 r569  
    4444#endif 
    4545 
    46 #define HAL_GENERIC_FN_EXCEPTION_CATCH(FUNCTION) 
    47 catch (const access_violation& e)  
    48 { 
    49         hal::event_log.post(shared_ptr<hal::EventDetail>( 
    50                 new hal::EventGeneral(hal::event_logger::warning, hal::event_logger::unclassified,  
    51                 (hal::wform(BOOST_PP_STRINGIZE(BOOST_PP_CAT(FUNCTION, L" access_violation (code %1$x) at %2$x. Bad address %3$x"))) % e.code() % (unsigned)e.where() % (unsigned)e.badAddress()).str()))); 
    52 } 
    53 catch (const win32_exception& e)  
    54 { 
    55         hal::event_log.post(shared_ptr<hal::EventDetail>( 
    56                 new hal::EventGeneral(hal::event_logger::warning, hal::event_logger::unclassified,  
    57                 (hal::wform(L"Alert handler win32_exception (code %1$x) at %2$x") % e.code() % (unsigned)e.where()).str()))); 
    58 } 
    59 catch(std::exception& e) 
    60 { 
    61         hal::event_log.post(shared_ptr<hal::EventDetail>(\ 
    62                 new hal::EventStdException(hal::event_logger::debug, e, L"SplashThread()"))); 
    63 } 
    64 catch(...) 
    65 { 
    66         HAL_DEV_MSG(L"SplashThread() catch all"); 
     46#define HAL_GENERIC_FN_EXCEPTION_CATCH(FUNCTION) \ 
     47catch (const access_violation& e) \ 
     48{ \ 
     49        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
     50                new hal::EventMsg(hal::wform(L"%1% access_violation (code %2$x) at %3$x. Bad address %4$x") % hal::to_wstr_shim(FUNCTION) % e.code() % (unsigned)e.where() % (unsigned)e.badAddress(), \ 
     51                        hal::event_logger::critical))); \ 
     52} \ 
     53catch (const win32_exception& e) \ 
     54{ \ 
     55        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
     56                new hal::EventMsg(hal::wform(L"%1% win32_exception (code %2$x) at %3$x") % hal::to_wstr_shim(FUNCTION) % e.code() % (unsigned)e.where(), \ 
     57                        hal::event_logger::critical))); \ 
     58} \ 
     59catch(std::exception& e) \ 
     60{ \ 
     61        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
     62                new hal::EventMsg(hal::wform(L"%1% std::exception, %2%") % hal::to_wstr_shim(FUNCTION) % hal::from_utf8(e.what()), \ 
     63                        hal::event_logger::critical))); \ 
     64} \ 
     65catch(...) \ 
     66{ \ 
     67        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
     68                new hal::EventMsg(hal::wform(L"%1% catch all") % hal::to_wstr_shim(FUNCTION), \ 
     69                        hal::event_logger::critical))); \ 
    6770} 
    6871 
  • trunk/src/halIni.hpp

    r564 r569  
    88 
    99// #define TXML_ARCHIVE_LOGGING 
     10#include "global/txml_ini_adapter.hpp" 
    1011#include "global/txml_oarchive.hpp" 
    1112#include "global/txml_iarchive.hpp" 
    1213 
    13 #include "global/txml_ini_adapter.hpp" 
    1414#include "halEvent.hpp" 
    1515 
  • trunk/src/halSession.cpp

    r564 r569  
    4949        dht_on_(false) 
    5050{ 
     51        try 
     52        { 
     53 
    5154        torrent_internal::the_session_ = &session_; 
    52         torrent_internal::workingDir_ = workingDir(); 
     55        torrent_internal::workingDir_ = hal::app().get_working_directory(); 
    5356         
    5457        session_.set_severity_level(libt::alert::debug);                 
     
    6871        try 
    6972        {                                                
    70         if (fs::exists(workingDirectory/L"Torrents.xml")) 
    71         { 
    72                 { 
    73                 fs::wifstream ifs(workingDirectory/L"Torrents.xml"); 
     73        if (fs::exists(hal::app().get_working_directory()/L"Torrents.xml")) 
     74        { 
     75                { 
     76                fs::wifstream ifs(hal::app().get_working_directory()/L"Torrents.xml"); 
    7477         
    7578                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Loading old Torrents.xml"))); 
     
    8588                        hal::wform(L"Total %1%.") % the_torrents_.size())));                             
    8689                 
    87                 fs::rename(workingDirectory/L"Torrents.xml", workingDirectory/L"Torrents.xml.safe.to.delete"); 
     90                fs::rename(hal::app().get_working_directory()/L"Torrents.xml", hal::app().get_working_directory()/L"Torrents.xml.safe.to.delete"); 
    8891        }                        
    8992        } 
     
    9497        }                
    9598                         
    96         if (exists(workingDirectory/L"DHTState.bin")) 
     99        if (exists(hal::app().get_working_directory()/L"DHTState.bin")) 
    97100        { 
    98101                try 
    99102                { 
    100                         dht_state_ = haldecode(workingDirectory/L"DHTState.bin"); 
     103                        dht_state_ = haldecode(hal::app().get_working_directory()/L"DHTState.bin"); 
    101104                }                
    102105                catch(const std::exception& e) 
     
    113116         
    114117        start_alert_handler(); 
     118 
     119        } HAL_GENERIC_FN_EXCEPTION_CATCH(L"bit_impl::bit_impl()") 
    115120} 
    116121 
    117122bit_impl::~bit_impl() 
    118 { 
     123{        
     124        try 
     125        { 
    119126        HAL_DEV_MSG(L"Commence ~BitTorrent_impl");  
    120127 
    121         stop_alert_handler(); 
    122          
     128        stop_alert_handler();    
    123129        //save_torrent_data(); 
    124          
    125         try 
    126         { 
    127130         
    128131        if (ip_filter_changed_) 
    129132        {        
    130                 fs::ofstream ofs(workingDirectory/L"IPFilter.bin", std::ios::binary); 
    131 //                      boost::archive::binary_oarchive oba(ofs); 
     133                fs::ofstream ofs(hal::app().get_working_directory()/L"IPFilter.bin", std::ios::binary); 
     134//              boost::archive::binary_oarchive oba(ofs); 
    132135                 
    133136                libt::ip_filter::filter_tuple_t vectors = ip_filter_.export_filter();    
     
    140143 
    141144                write_vec_range(ofs, v4); 
    142 //                      write_vec_range(ofs, v6); 
     145//              write_vec_range(ofs, v6); 
    143146        }        
    144         } 
    145         catch(std::exception& e) 
    146         { 
    147                 hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    148                         new hal::EventStdException(event_logger::critical, e, L"~BitTorrent_impl")));  
    149         } 
    150         catch(...) 
    151         { 
    152                 hal::event_log.post(shared_ptr<hal::EventDetail>( 
    153                         new hal::EventGeneral(hal::event_logger::warning,  
    154                                 hal::event_logger::unclassified, L"End ~BitTorrent_impl catch all"))); 
    155         } 
    156  
    157         HAL_DEV_MSG(L"~BitTorrent_impl");  
     147 
     148        } HAL_GENERIC_FN_EXCEPTION_CATCH(L"~BitTorrent_impl") 
    158149} 
    159150 
     
    171162void bit_impl::ip_filter_load(progress_callback fn) 
    172163{ 
    173         fs::ifstream ifs(workingDirectory/L"IPFilter.bin", std::ios::binary); 
     164        fs::ifstream ifs(hal::app().get_working_directory()/L"IPFilter.bin", std::ios::binary); 
    174165        if (ifs) 
    175166        { 
     
    294285bool bit_impl::create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn) 
    295286{                
    296 try 
    297 { 
     287        try 
     288        { 
    298289        libt::file_storage fs; 
    299290        libt::file_pool f_pool; 
     
    375366        halencode(out_file, e); 
    376367 
    377         } 
    378         catch(const std::exception& e) 
    379         { 
    380                 event_log.post(shared_ptr<EventDetail>( 
    381                         new EventStdException(event_logger::fatal, e, L"create_torrent"))); 
    382         }        
     368        } HAL_GENERIC_FN_EXCEPTION_CATCH(L"bit_impl::create_torrent()") 
    383369 
    384370        return false; 
     
    709695                { 
    710696                mutex_t::scoped_lock l(mutex_); 
    711          
    712                 HAL_DEV_MSG(hal::wform(L"DEV_MSG: %1%") % from_utf8(p_alert->message())); 
    713697                 
    714698                libt::handle_alert< 
     
    757741        } 
    758742 
    759         } 
    760         catch (const win32_exception& e) { 
    761                 hal::event_log.post(shared_ptr<hal::EventDetail>( 
    762                         new hal::EventGeneral(hal::event_logger::warning, hal::event_logger::unclassified,  
    763                         (hal::wform(L"Alert handler win32_exception (code %1%) at %2%") % e.code() % 123).str()))); 
    764     } 
    765         catch(std::exception& e) 
    766         { 
    767                 // These are logged as debug because they are rarely important to act on! 
    768                 event_log.post(shared_ptr<EventDetail>(\ 
    769                         new EventStdException(event_logger::debug, e, L"alertHandler"))); 
    770         } 
    771  
    772         catch(...) 
    773         { 
    774                 hal::event_log.post(shared_ptr<hal::EventDetail>( 
    775                         new hal::EventGeneral(hal::event_logger::warning, hal::event_logger::unclassified, L"Alert handler catch all"))); 
    776         } 
    777 } 
    778  
    779 } 
     743        } HAL_GENERIC_FN_EXCEPTION_CATCH(L"bit_impl::alert_handler()") 
     744} 
     745 
     746} 
  • trunk/src/halSession.hpp

    r554 r569  
    699699                 
    700700                wpath torrentFilename = torrentName; 
    701                 const wpath resumeFile = workingDirectory/L"resume"/torrentFilename.filename(); 
     701                const wpath resumeFile = hal::app().get_working_directory()/L"resume"/torrentFilename.filename(); 
    702702                 
    703703                //  vvv Handle old naming style! 
    704                 const wpath oldResumeFile = workingDirectory/L"resume"/filename.filename(); 
     704                const wpath oldResumeFile = hal::app().get_working_directory()/L"resume"/filename.filename(); 
    705705                 
    706706                if (filename.filename() != torrentFilename.filename() && exists(oldResumeFile)) 
     
    725725                } 
    726726 
    727                 if (!fs::exists(workingDirectory/L"torrents")) 
    728                         fs::create_directory(workingDirectory/L"torrents"); 
    729  
    730                 if (!fs::exists(workingDirectory/L"torrents"/torrentFilename.filename())) 
    731                         fs::copy_file(filename.string(), workingDirectory/L"torrents"/torrentFilename.filename()); 
     727                if (!fs::exists(hal::app().get_working_directory()/L"torrents")) 
     728                        fs::create_directory(hal::app().get_working_directory()/L"torrents"); 
     729 
     730                if (!fs::exists(hal::app().get_working_directory()/L"torrents"/torrentFilename.filename())) 
     731                        fs::copy_file(filename.string(), hal::app().get_working_directory()/L"torrents"/torrentFilename.filename()); 
    732732 
    733733                if (!fs::exists(saveDirectory)) 
     
    826826                for (TorrentManager::torrentByName::iterator i=the_torrents_.begin(), e=the_torrents_.end(); i != e;) 
    827827                { 
    828                         wpath file = wpath(workingDirectory)/L"torrents"/(*i).torrent->filename(); 
     828                        wpath file = wpath(hal::app().get_working_directory())/L"torrents"/(*i).torrent->filename(); 
    829829                         
    830830                        if (exists(file)) 
     
    927927                if (dht_on_)  
    928928                {        
    929                         halencode(workingDirectory/L"DHTState.bin", session_.dht_state()); 
     929                        halencode(hal::app().get_working_directory()/L"DHTState.bin", session_.dht_state()); 
    930930                } 
    931931                 
     
    943943        float defTorrentUpload() { return defTorrentUpload_; } 
    944944         
    945         const wpath workingDir() { return workingDirectory; }; 
    946  
    947945private: 
    948946        bool create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn); 
     
    954952        bool keepChecking_; 
    955953         
    956         static wpath workingDirectory; 
     954        wpath working_directory_; 
    957955        ini_file bittorrentIni; 
    958956        TorrentManager the_torrents_;    
  • trunk/src/halTorrent.cpp

    r564 r569  
    9999        type(hal::app().res_wstr(HAL_INT_NEWT_ADD_PEERS_DHT))  
    100100{} 
    101 wpath bit_impl::workingDirectory = hal::app().working_directory; 
    102101 
    103102bit::bit() : 
     
    112111}\ 
    113112catch (const invalidTorrent& t) \ 
     113{ \ 
     114        event_log.post(shared_ptr<EventDetail>( \ 
     115                new EventInvalidTorrent(event_logger::info, event_logger::invalidTorrent, t.who(), std::string(FUNCTION)))); \ 
     116} \ 
     117catch (const access_violation& e) \ 
     118{ \ 
     119        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
     120                new hal::EventMsg(hal::wform(L"Torrent property %1% access_violation (code %2$x) at %3$x. Bad address %4$x") % hal::from_utf8(FUNCTION) % e.code() % (unsigned)e.where() % (unsigned)e.badAddress(), \ 
     121                        hal::event_logger::critical))); \ 
     122} \ 
     123catch (const win32_exception& e) \ 
     124{ \ 
     125        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
     126                new hal::EventMsg(hal::wform(L"Torrent property %1% win32_exception (code %2$x) at %3$x") % hal::from_utf8(FUNCTION) % e.code() % (unsigned)e.where(), \ 
     127                        hal::event_logger::critical))); \ 
     128} \ 
     129catch (const std::exception& e) \ 
     130{ \ 
     131        event_log.post(shared_ptr<EventDetail>( \ 
     132                new EventTorrentException(event_logger::critical, event_logger::torrentException, std::string(e.what()), name, std::string(FUNCTION)))); \ 
     133} \ 
     134catch(...) \ 
     135{ \ 
     136        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
     137                new hal::EventMsg(hal::wform(L"%1% catch all") % hal::from_utf8(FUNCTION), \ 
     138                        hal::event_logger::critical))); \ 
     139} 
     140 
     141#define HAL_GENERIC_TORRENT_EXCEPTION_CATCH(TORRENT, FUNCTION) \ 
     142catch (const libt::invalid_handle&) \ 
     143{\ 
     144        event_log.post(shared_ptr<EventDetail>( \ 
     145                new EventInvalidTorrent(event_logger::critical, event_logger::invalidTorrent, TORRENT, std::string(FUNCTION)))); \ 
     146}\ 
     147catch (const invalidTorrent& t) \ 
    114148{\ 
    115149        event_log.post(shared_ptr<EventDetail>( \ 
    116150                new EventInvalidTorrent(event_logger::info, event_logger::invalidTorrent, t.who(), std::string(FUNCTION)))); \ 
    117151}\ 
     152catch (const access_violation& e) \ 
     153{ \ 
     154        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
     155                new hal::EventMsg(hal::wform(L"Generic Torrent %1% access_violation (code %2$x) at %3$x. Bad address %4$x (%5%)") % hal::from_utf8(FUNCTION) % e.code() % (unsigned)e.where() % (unsigned)e.badAddress() % TORRENT, \ 
     156                        hal::event_logger::critical))); \ 
     157} \ 
     158catch (const win32_exception& e) \ 
     159{ \ 
     160        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
     161                new hal::EventMsg(hal::wform(L"Generic Torrent %1% win32_exception (code %2$x) at %3$x (%4%)") % hal::from_utf8(FUNCTION) % e.code() % (unsigned)e.where() % TORRENT, \ 
     162                        hal::event_logger::critical))); \ 
     163} \ 
    118164catch (const std::exception& e) \ 
    119 {\ 
     165{ \ 
    120166        event_log.post(shared_ptr<EventDetail>( \ 
    121                 new EventTorrentException(event_logger::critical, event_logger::torrentException, std::string(e.what()), name, std::string(FUNCTION)))); \ 
     167                new EventTorrentException(event_logger::critical, event_logger::torrentException, std::string(e.what()), TORRENT, std::string(FUNCTION)))); \ 
     168} \ 
     169catch (...) \ 
     170{ \ 
     171        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
     172                new hal::EventMsg(hal::wform(L"Generic Torrent %1% catch all") % hal::from_utf8(FUNCTION), \ 
     173                        hal::event_logger::critical))); \ 
    122174} 
    123175 
Note: See TracChangeset for help on using the changeset viewer.