"cc1plus.exe çalışmayı durdurdu" Boost Spirit kodunu derlerken

Question

Windows Vista Home Premium 64 altında MinGW'nin en son sürümünü (GCC 4.5.2) kullanarak bazı kodları derlemeye çalışırken biraz tuhaf bir sorun yaşıyorum -bit. Bu dosyayı derlerken "cc1plus.exe'nin çalışmayı durdurduğuna" dair bir mesaj alıyorum ve derleme hata mesajı olmadan başarısız oluyor. Hala sorun üreten mutlak minimumda aşağı dosyayı şerit çalıştılar: ayıklama sembolleri (-g) etkinse bu soyulmuş aşağı versiyonda

#include <boost/spirit/include/classic_file_iterator.hpp> 
#include <boost/spirit/include/classic_position_iterator.hpp> 
#include <boost/fusion/include/adapt_struct.hpp> 
#include <boost/spirit/include/phoenix.hpp> 
#include <boost/spirit/include/phoenix_fusion.hpp> 
#include <boost/spirit/include/phoenix_stl.hpp> 
#include <boost/spirit/include/qi.hpp> 
#include <vector> 

#define BOOST_SPIRIT_AUTO(domain_, name, expr)         \ 
    typedef boost::proto::result_of::           \ 
     deep_copy<BOOST_TYPEOF(expr)>::type name##_expr_type;     \ 
    BOOST_SPIRIT_ASSERT_MATCH(             \ 
     boost::spirit::domain_::domain, name##_expr_type);      \ 
    BOOST_AUTO(name, boost::proto::deep_copy(expr));       \ 

using namespace std; 

//This structure is used to determine the situation in which a certain tile sprite is used. 
struct TileCase { 
    //A vector of bit fields for which adjacent tiles which must be filled. 
    vector<unsigned> filled; 

    //A vector of bit fields for which adjacent tiles are optionally filled. 
    vector<unsigned> optionalFilled; 

    TileCase() : filled(0), 
        optionalFilled(0){} 
}; 

//Adapt the TileCase struct to a Fusion tuple. 
BOOST_FUSION_ADAPT_STRUCT (
    TileCase, 
    (std::vector<unsigned>, filled) 
    (std::vector<unsigned>, optionalFilled) 
) 

namespace qi = boost::spirit::qi; 
namespace phoenix = boost::phoenix; 
namespace ascii = boost::spirit::ascii; 
using phoenix::function; 
using ascii::space; 
using ascii::char_; 
using qi::eol; 

//A skipper rule for comments. 
BOOST_SPIRIT_AUTO(qi, comment, ("/*" >> *(char_ - "*/") >> "*/") 
           | ascii::space 
           | ("//" >> *(char_ - eol) >> eol) 
           ); 

//The Spirit error handler. 
struct error_handler_ { 
    template<typename, typename, typename> 
    struct result { typedef void type; }; 

    template <typename Iterator> 
    void operator()(
     qi::info const& what, 
     Iterator err_pos, Iterator last) const 
    { 
     //Get the line position. 
     boost::spirit::classic::file_position_base<string> const& pos = err_pos.get_position(); 

     //Throw an error. 
     stringstream error; 
     error << "Error! Expecting " 
       << what 
       << " at line " 
       << pos.line 
       << ", column " 
       << pos.column 
       << "!"; 
     throw(runtime_error(error.str())); 
    } 
}; 

function<error_handler_> const error_handler = error_handler_(); 

//The Spirit grammar for parsing tile data. 
template<typename Iterator> 
struct tileData : qi::grammar<Iterator, vector<TileCase>(), comment_expr_type> { 
    //The rule called when the parsing starts. 
    qi::rule<Iterator, vector<TileCase>(), comment_expr_type> start; 

    //The rule for parsing a single tile case. 
    qi::rule<Iterator, TileCase(), qi::locals<unsigned>, comment_expr_type> tile; 

    //The rule which parses yes/no/either bitflag blocks. 
    //Takes two references to unsigned, the first being the yes/no flag and the second being the optional flag. 
    qi::rule<Iterator, void(unsigned&, unsigned&), qi::locals<unsigned>, comment_expr_type> condBlock; 

    tileData() : tileData::base_type(start) { 
     using qi::eps; 
     using qi::lit; 
     using qi::on_error; 
     using qi::fail; 
     using qi::uint_; 
     using phoenix::at_c; 
     using phoenix::push_back; 
     using phoenix::resize; 
     using namespace qi::labels; 

     start = *tile[push_back(_val, _1)]; 

     tile = 
      //Parse the filled definition. 
      lit("filled") 

     > '(' 
      //Parse the generation to check for fills. 
     > uint_ 
      [ 
       _a = _1, 
       resize(at_c<0>(_val), _1 + 1), 
       resize(at_c<1>(_val), _1 + 1) 
      ] 
     > ')' 
      //Opening curly bracket for filled definition. 
     > '{' 
      //The condition block. 
     > condBlock 
      (
       //This one goes to filled[_a], 
       (at_c<0>(_val))[_a], 
       //and optionalFilled[_a]. 
       (at_c<1>(_val))[_a] 
      ) 
      //Closing curly bracket for filled definition. 
     > '}' 
     ; 

     condBlock = 
      eps 
      [_a = 1] 
     >> 
      (
      * (
        (
         +lit('+') 
         [_r1 += _a, _a *= 2] 
        ) 
       | 
        (
         +lit('*') 
         [_r2 += _a, _a *= 2] 
        ) 
       | 
        (
         +lit('-') 
         [_a *= 2] 
        ) 
       ) 
      ) 
     ; 

     on_error<fail> 
     (
      start, 
      error_handler(_4, _3, _2) 
     ); 
    } 
}; 


int main() { 
    try { 
     //Set up the file iterator. 
     typedef char char_type; 
     typedef boost::spirit::classic::file_iterator<char_type> iterator_type; 

     //Open the file. 
     iterator_type first("Test.txt"); 

     //Make sure the file is open. 
     if (!first) throw(runtime_error("Failed to open file!")); 

     //Find the end of the file. 
     iterator_type last = first.make_end(); 

     //Wrap the file iterator with a position iterator. 
     typedef boost::spirit::classic::position_iterator2<iterator_type> pos_iterator_type; 
     typedef tileData<pos_iterator_type> tileData; 
     pos_iterator_type pos_first(first, last, "Test.txt"); 
     pos_iterator_type pos_last; 

     //Prepare parsing information. 
     tileData tileData_parser; 
     vector<TileCase> cases; 

     //Parse the file. 
     if (phrase_parse(pos_first, pos_last, tileData_parser, comment, cases) && pos_first == pos_last) { 
      //Do something... 
     } 
    } 
    catch (const exception& e) { 
     cerr << "Exception while reading file:\n" << e.what() << endl; 
     return 1; 
    } 

    return 0; 
} 

, derleyici sadece çöker. Ancak, dosyanın tam sürümüyle, ne olursa olsun çöküyor. Ayrıca, Ruh kodunun bir kısmı kaldırılırsa (hata işleyicisi veya yorum kaptanı gibi), ayrıca doğru şekilde derler. Bu bana derleyicinin bellek yetersiz kaldığını gösteriyor, ama nasıl düzelteceğime emin değilim.

Doğrudan Code :: Blocks içinden komut satırından oluşturmayı denedim, ancak cc1plus hala çöküyor. Etkinleştirdiğim tek derleyici bayrağı -g. Sadece bir MinGW kurulumuna sahip olduğumu iki kez kontrol ettim ve yeniden kurmayı denedim, ancak sorun devam ediyor. Bunun olmasına ne sebep olur?

Answer 1

Bu gcc/MingW ile ilgili bilinen bir sorundur, ancak durumun ne olduğunu bilmiyorum (tümüyle yeniden oluşturulmuş olup olmadığını bilmiyorum.). Ruh mail listesindeki birisi varsayılan yığın boyutunu artıran bir yama önerdi cc1plus.exe için, sorunun giderildiği bildirildi. Yine de kendimi denemedim.

Answer 2

yaklaşık 128M, işte son düzenlenmiş cevap bakınız olan pch dosya için bir sabit sınır değeri var gibi görünüyor: https://stackoverflow.com/a/19372020/154911 Ben mingw-w64 forumda soruyorum yeni bir toolchain inşa edip edemeyeceğini görmek için Bu sorunu gidermek için.