Changeset 81797


Ignore:
Timestamp:
Dec 8, 2012, 4:31:17 PM (6 years ago)
Author:
Hartmut Kaiser
Message:

Spirit: merging from trunk

Location:
branches/release
Files:
24 edited
3 copied

Legend:

Unmodified
Added
Removed
  • branches/release

  • branches/release/boost

  • branches/release/boost/spirit

  • branches/release/boost/spirit/home

  • branches/release/boost/spirit/home/classic/iterator/multi_pass.hpp

    r46610 r81797  
    195195
    196196        // called to verify that everything is okay.
    197         void check() const
     197        void check_if_valid() const
    198198        {
    199199            if (buf_id != *shared_buf_id)
     
    227227        void destroy() {}
    228228        void swap(no_check&) {}
    229         void check() const {}
     229        void check_if_valid() const {}
    230230        void clear_queue() {}
    231231};
     
    10011001operator*() const
    10021002{
    1003     CHP::check();
     1003    CHP::check_if_valid();
    10041004    return SP::dereference(*this);
    10051005}
     
    10351035operator++()
    10361036{
    1037     CHP::check();
     1037    CHP::check_if_valid();
    10381038    SP::increment(*this);
    10391039    return *this;
  • branches/release/boost/spirit/home/karma

  • branches/release/boost/spirit/home/karma.hpp

    r68078 r81797  
    11//  Copyright (c) 2001-2011 Hartmut Kaiser
    2 // 
    3 //  Distributed under the Boost Software License, Version 1.0. (See accompanying 
     2//
     3//  Distributed under the Boost Software License, Version 1.0. (See accompanying
    44//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
    55
  • branches/release/boost/spirit/home/karma/detail/output_iterator.hpp

    r70657 r81797  
    2222#include <boost/spirit/home/support/iterators/ostream_iterator.hpp>
    2323#include <boost/spirit/home/support/unused.hpp>
     24
     25#if defined(BOOST_MSVC) && defined(BOOST_SPIRIT_UNICODE)
     26#include <boost/spirit/home/support/char_encoding/unicode.hpp>
     27#endif
    2428
    2529namespace boost { namespace spirit { namespace karma { namespace detail
     
    6569        template <typename T>
    6670        void output(T const& value)
    67         { 
     71        {
    6872            // track position in the output
    6973            track_position_data.output(value);
     
    111115
    112116        void output()
    113         { 
     117        {
    114118            ++count;
    115119        }
     
    148152        template <typename T>
    149153        void output(T const&)
    150         { 
     154        {
    151155            // count characters, if appropriate
    152156            if (NULL != count)
     
    173177    class buffer_sink : boost::noncopyable
    174178    {
     179       // wchar_t is only 16-bits on Windows. If BOOST_SPIRIT_UNICODE is
     180       // defined, the character type is 32-bits wide so we need to make
     181       // sure the buffer is at least that wide.
     182#if defined(BOOST_MSVC) && defined(BOOST_SPIRIT_UNICODE)
     183       typedef spirit::char_encoding::unicode::char_type buffer_char_type;
     184#else
     185       typedef wchar_t buffer_char_type;
     186#endif
     187
    175188    public:
    176189        buffer_sink()
     
    178191
    179192        ~buffer_sink()
    180         { 
     193        {
    181194            tidy();
    182195        }
    183196
    184197        void enable(std::size_t width_)
    185         { 
     198        {
    186199            tidy();             // release existing buffer
    187200            width = (width_ == std::size_t(-1)) ? 0 : width_;
     
    190203
    191204        void tidy()
    192         { 
     205        {
    193206            buffer.clear();
    194207            width = 0;
     
    198211        void output(T const& value)
    199212        {
    200             BOOST_STATIC_ASSERT(sizeof(T) <= sizeof(wchar_t));
     213            BOOST_STATIC_ASSERT(sizeof(T) <= sizeof(buffer_char_type));
    201214            buffer.push_back(value);
    202215        }
     
    204217        template <typename OutputIterator_>
    205218        bool copy(OutputIterator_& sink, std::size_t maxwidth) const
    206         { 
     219        {
    207220#if defined(BOOST_MSVC)
    208221#pragma warning(push)
    209222#pragma warning(disable: 4267)
    210223#endif
    211             typename std::basic_string<wchar_t>::const_iterator end =
     224            typename std::basic_string<buffer_char_type>::const_iterator end =
    212225                buffer.begin() + (std::min)(buffer.size(), maxwidth);
    213226
     
    220233        template <typename RestIterator>
    221234        bool copy_rest(RestIterator& sink, std::size_t start_at) const
    222         { 
     235        {
    223236#if defined(BOOST_MSVC)
    224237#pragma warning(push)
    225238#pragma warning(disable: 4267)
    226239#endif
    227             typename std::basic_string<wchar_t>::const_iterator begin =
     240            typename std::basic_string<buffer_char_type>::const_iterator begin =
    228241                buffer.begin() + (std::min)(buffer.size(), start_at);
    229242
     
    236249
    237250        std::size_t buffer_size() const
    238         { 
     251        {
    239252            return buffer.size();
    240253        }
     
    242255    private:
    243256        std::size_t width;
    244         std::basic_string<wchar_t> buffer;
     257        std::basic_string<buffer_char_type> buffer;
    245258    };
    246259
     
    453466        bool good() const { return true; }
    454467
     468        // allow to access underlying output iterator
     469        OutputIterator& base() { return *sink; }
     470
    455471    protected:
    456472        // this is the wrapped user supplied output iterator
  • branches/release/boost/spirit/home/karma/numeric/detail/numeric_utils.hpp

    r71375 r81797  
    11//  Copyright (c) 2001-2011 Hartmut Kaiser
    2 // 
    3 //  Distributed under the Boost Software License, Version 1.0. (See accompanying 
     2//
     3//  Distributed under the Boost Software License, Version 1.0. (See accompanying
    44//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
    55
     
    2626///////////////////////////////////////////////////////////////////////////////
    2727//
    28 //  The value BOOST_KARMA_NUMERICS_LOOP_UNROLL specifies, how to unroll the 
     28//  The value BOOST_KARMA_NUMERICS_LOOP_UNROLL specifies, how to unroll the
    2929//  integer string generation loop (see below).
    3030//
    31 //      Set the value to some integer in between 0 (no unrolling) and the 
    32 //      largest expected generated integer string length (complete unrolling). 
     31//      Set the value to some integer in between 0 (no unrolling) and the
     32//      largest expected generated integer string length (complete unrolling).
    3333//      If not specified, this value defaults to 6.
    3434//
     
    3838#endif
    3939
    40 #if BOOST_KARMA_NUMERICS_LOOP_UNROLL < 0 
     40#if BOOST_KARMA_NUMERICS_LOOP_UNROLL < 0
    4141#error "Please set the BOOST_KARMA_NUMERICS_LOOP_UNROLL to a non-negative value!"
    4242#endif
    4343
    4444namespace boost { namespace spirit { namespace traits
    45 { 
    46     ///////////////////////////////////////////////////////////////////////
    47     //
    48     //  return the absolute value from a given number, avoiding over- and 
     45{
     46    ///////////////////////////////////////////////////////////////////////
     47    //
     48    //  return the absolute value from a given number, avoiding over- and
    4949    //  underflow
    5050    //
     
    154154    struct is_negative
    155155    {
    156         static bool call(T n) 
    157         { 
    158             return (n < 0) ? true : false; 
     156        static bool call(T n)
     157        {
     158            return (n < 0) ? true : false;
    159159        }
    160160    };
     
    163163    struct is_negative<float>
    164164    {
    165         static bool call(float n) 
    166         { 
    167             return (spirit::detail::signbit)(n) ? true : false; 
     165        static bool call(float n)
     166        {
     167            return (spirit::detail::signbit)(n) ? true : false;
    168168        }
    169169    };
     
    172172    struct is_negative<double>
    173173    {
    174         static bool call(double n) 
    175         { 
    176             return (spirit::detail::signbit)(n) ? true : false; 
     174        static bool call(double n)
     175        {
     176            return (spirit::detail::signbit)(n) ? true : false;
    177177        }
    178178    };
     
    181181    struct is_negative<long double>
    182182    {
    183         static bool call(long double n) 
    184         { 
    185             return (spirit::detail::signbit)(n) ? true : false; 
     183        static bool call(long double n)
     184        {
     185            return (spirit::detail::signbit)(n) ? true : false;
    186186        }
    187187    };
     
    197197    struct is_zero
    198198    {
    199         static bool call(T n) 
    200         { 
    201             return (n == 0) ? true : false; 
     199        static bool call(T n)
     200        {
     201            return (n == 0) ? true : false;
    202202        }
    203203    };
     
    206206    struct is_zero<float>
    207207    {
    208         static bool call(float n) 
    209         { 
    210             return (math::fpclassify)(n) == FP_ZERO; 
     208        static bool call(float n)
     209        {
     210            return (math::fpclassify)(n) == FP_ZERO;
    211211        }
    212212    };
     
    215215    struct is_zero<double>
    216216    {
    217         static bool call(double n) 
    218         { 
    219             return (math::fpclassify)(n) == FP_ZERO; 
     217        static bool call(double n)
     218        {
     219            return (math::fpclassify)(n) == FP_ZERO;
    220220        }
    221221    };
     
    224224    struct is_zero<long double>
    225225    {
    226         static bool call(long double n) 
    227         { 
    228             return (math::fpclassify)(n) == FP_ZERO; 
     226        static bool call(long double n)
     227        {
     228            return (math::fpclassify)(n) == FP_ZERO;
    229229        }
    230230    };
     
    240240    struct is_nan
    241241    {
    242         static bool call(T n) 
    243         { 
     242        static bool call(T n)
     243        {
    244244            // NaN numbers are not equal to anything
    245245            return (n != n) ? true : false;
     
    250250    struct is_nan<float>
    251251    {
    252         static bool call(float n) 
    253         { 
    254             return (math::fpclassify)(n) == FP_NAN; 
     252        static bool call(float n)
     253        {
     254            return (math::fpclassify)(n) == FP_NAN;
    255255        }
    256256    };
     
    259259    struct is_nan<double>
    260260    {
    261         static bool call(double n) 
    262         { 
    263             return (math::fpclassify)(n) == FP_NAN; 
     261        static bool call(double n)
     262        {
     263            return (math::fpclassify)(n) == FP_NAN;
    264264        }
    265265    };
     
    268268    struct is_nan<long double>
    269269    {
    270         static bool call(long double n) 
    271         { 
    272             return (math::fpclassify)(n) == FP_NAN; 
     270        static bool call(long double n)
     271        {
     272            return (math::fpclassify)(n) == FP_NAN;
    273273        }
    274274    };
     
    284284    struct is_infinite
    285285    {
    286         static bool call(T n)
    287         {
    288           return (n == std::numeric_limits<T>::infinity()) ? true : false;
     286        static bool call(T n)
     287        {
     288            if (!std::numeric_limits<T>::has_infinity)
     289                return false;
     290            return (n == std::numeric_limits<T>::infinity()) ? true : false;
    289291        }
    290292    };
     
    293295    struct is_infinite<float>
    294296    {
    295         static bool call(float n) 
    296         { 
    297             return (math::fpclassify)(n) == FP_INFINITE; 
     297        static bool call(float n)
     298        {
     299            return (math::fpclassify)(n) == FP_INFINITE;
    298300        }
    299301    };
     
    302304    struct is_infinite<double>
    303305    {
    304         static bool call(double n) 
    305         { 
    306             return (math::fpclassify)(n) == FP_INFINITE; 
     306        static bool call(double n)
     307        {
     308            return (math::fpclassify)(n) == FP_INFINITE;
    307309        }
    308310    };
     
    311313    struct is_infinite<long double>
    312314    {
    313         static bool call(long double n) 
    314         { 
    315             return (math::fpclassify)(n) == FP_INFINITE; 
     315        static bool call(long double n)
     316        {
     317            return (math::fpclassify)(n) == FP_INFINITE;
    316318        }
    317319    };
     
    344346        static long call(T n, mpl::false_)
    345347        {
    346             // allow for ADL to find the correct overload for floor and 
     348            // allow for ADL to find the correct overload for floor and
    347349            // lround
    348350            using namespace std;
     
    368370        static long call(float n, mpl::false_)
    369371        {
    370             return test_negative(n) ? static_cast<long>(std::ceil(n)) : 
     372            return test_negative(n) ? static_cast<long>(std::ceil(n)) :
    371373                static_cast<long>(std::floor(n));
    372374        }
     
    374376        static long call(double n, mpl::false_)
    375377        {
    376             return test_negative(n) ? static_cast<long>(std::ceil(n)) : 
     378            return test_negative(n) ? static_cast<long>(std::ceil(n)) :
    377379                static_cast<long>(std::floor(n));
    378380        }
     
    380382        static long call(long double n, mpl::false_)
    381383        {
    382             return test_negative(n) ? static_cast<long>(std::ceil(n)) : 
     384            return test_negative(n) ? static_cast<long>(std::ceil(n)) :
    383385                static_cast<long>(std::floor(n));
    384386        }
     
    409411    //  Traits class for radix specific number conversion
    410412    //
    411     //      Convert a digit from binary representation to character 
     413    //      Convert a digit from binary representation to character
    412414    //      representation:
    413415    //
     
    452454
    453455    template <unsigned Radix, typename CharEncoding, typename Tag>
    454     struct convert_digit 
     456    struct convert_digit
    455457      : detail::convert_digit<CharEncoding, Tag, (Radix <= 10) ? true : false>
    456458    {};
     
    470472        {
    471473            // Allow ADL to find the correct overload for floor
    472             using namespace std; 
     474            using namespace std;
    473475            return floor(n / Radix);
    474476        }
     
    501503        {
    502504            // Allow ADL to find the correct overload for floor
    503             using namespace std; 
     505            using namespace std;
    504506            return floor(num / spirit::traits::pow10<T>(exp));
    505507        }
     
    525527        static long call(T n, mpl::true_)
    526528        {
    527             // this cast is safe since we know the result is not larger 
     529            // this cast is safe since we know the result is not larger
    528530            // than Radix
    529531            return static_cast<long>(n % Radix);
     
    534536        {
    535537            // Allow ADL to find the correct overload for fmod
    536             using namespace std; 
     538            using namespace std;
    537539            return cast_to_long::call(fmod(n, T(Radix)));
    538540        }
     
    546548}}}
    547549
    548 namespace boost { namespace spirit { namespace karma 
    549 { 
     550namespace boost { namespace spirit { namespace karma
     551{
    550552    ///////////////////////////////////////////////////////////////////////////
    551553    //
    552     //  The int_inserter template takes care of the integer to string 
     554    //  The int_inserter template takes care of the integer to string
    553555    //  conversion. If specified, the loop is unrolled for better performance.
    554556    //
    555     //      Set the value BOOST_KARMA_NUMERICS_LOOP_UNROLL to some integer in 
    556     //      between 0 (no unrolling) and the largest expected generated integer 
    557     //      string length (complete unrolling). 
     557    //      Set the value BOOST_KARMA_NUMERICS_LOOP_UNROLL to some integer in
     558    //      between 0 (no unrolling) and the largest expected generated integer
     559    //      string length (complete unrolling).
    558560    //      If not specified, this value defaults to 6.
    559561    //
     
    592594                BOOST_KARMA_NUMERICS_INNER_LOOP_PREFIX, _);
    593595
    594             if (!traits::test_zero(n)) 
     596            if (!traits::test_zero(n))
    595597                call(sink, n, num, exp);
    596598
     
    628630
    629631    public:
    630         // Specialization for doubles and floats, falling back to long integers 
     632        // Specialization for doubles and floats, falling back to long integers
    631633        // for representable values. These specializations speed up formatting
    632         // of floating point numbers considerably as all the required 
     634        // of floating point numbers considerably as all the required
    633635        // arithmetics will be executed using integral data types.
    634636        template <typename OutputIterator>
     
    672674    ///////////////////////////////////////////////////////////////////////////
    673675    //
    674     //  The uint_inserter template takes care of the conversion of any integer 
     676    //  The uint_inserter template takes care of the conversion of any integer
    675677    //  to a string, while interpreting the number as an unsigned type.
    676678    //
     
    698700    //  The sign_inserter template generates a sign for a given numeric value.
    699701    //
    700     //    The parameter forcesign allows to generate a sign even for positive 
     702    //    The parameter forcesign allows to generate a sign even for positive
    701703    //    numbers.
    702704    //
     
    721723        {
    722724            // generate a sign for all numbers except zero
    723             if (!is_zero) 
     725            if (!is_zero)
    724726                *sink = is_negative ? '-' : '+';
    725             else 
     727            else
    726728                *sink = ' ';
    727729
  • branches/release/boost/spirit/home/karma/numeric/detail/real_utils.hpp

    r71375 r81797  
    4747        {
    4848            if (traits::test_nan(n)) {
    49                 return Policies::template nan<CharEncoding, Tag>(
     49                return p.template nan<CharEncoding, Tag>(
    5050                    sink, n, p.force_sign(n));
    5151            }
    5252            else if (traits::test_infinite(n)) {
    53                 return Policies::template inf<CharEncoding, Tag>(
     53                return p.template inf<CharEncoding, Tag>(
    5454                    sink, n, p.force_sign(n));
    5555            }
  • branches/release/boost/spirit/home/karma/operator/list.hpp

    r70574 r81797  
    4848        bool generate_left(F f, Attribute const&, mpl::false_) const
    4949        {
    50             // Failing subject generators are just skipped. This allows to 
     50            // Failing subject generators are just skipped. This allows to
    5151            // selectively generate items in the provided attribute.
    5252            while (!f.is_at_end())
    5353            {
    5454                bool r = !f(left);
    55                 if (r) 
     55                if (r)
    5656                    return true;
    5757                if (!f.is_at_end())
     
    6767        }
    6868
    69         // There is no way to distinguish a failed generator from a 
     69        // There is no way to distinguish a failed generator from a
    7070        // generator to be skipped. We assume the user takes responsibility
    7171        // for ending the loop if no attribute is specified.
     
    8181
    8282        typedef mpl::int_<
    83             left_type::properties::value 
    84           | right_type::properties::value 
    85           | generator_properties::buffering 
     83            left_type::properties::value
     84          | right_type::properties::value
     85          | generator_properties::buffering
    8686          | generator_properties::counting
    8787        > properties;
     
    9797
    9898        base_list(Left const& left, Right const& right)
    99           : left(left), right(right) 
     99          : left(left), right(right)
    100100        {}
    101101
     
    114114            >::type iterator_type;
    115115
    116             typedef 
    117                 typename traits::make_indirect_iterator<iterator_type>::type 
     116            typedef
     117                typename traits::make_indirect_iterator<iterator_type>::type
    118118            indirect_iterator_type;
    119119            typedef detail::pass_container<
     
    124124            iterator_type end = traits::end(attr);
    125125
    126             pass_container pass(fail_function(sink, ctx, d), 
     126            pass_container pass(fail_function(sink, ctx, d),
    127127                indirect_iterator_type(it), indirect_iterator_type(end));
    128128
     
    161161
    162162    template <typename Left, typename Right>
    163     struct list 
     163    struct list
    164164      : base_list<Left, Right, mpl::false_, list<Left, Right> >
    165165    {
     
    171171
    172172    template <typename Left, typename Right>
    173     struct strict_list 
     173    struct strict_list
    174174      : base_list<Left, Right, mpl::true_, strict_list<Left, Right> >
    175175    {
     
    186186    {
    187187        template <typename Subject, bool strict_mode = false>
    188         struct make_list 
     188        struct make_list
    189189          : make_binary_composite<Subject, list>
    190190        {};
    191191
    192192        template <typename Subject>
    193         struct make_list<Subject, true> 
     193        struct make_list<Subject, true>
    194194          : make_binary_composite<Subject, strict_list>
    195195        {};
     
    217217      , typename Context, typename Iterator>
    218218    struct handles_container<karma::list<Left, Right>, Attribute
    219           , Context, Iterator> 
     219          , Context, Iterator>
    220220      : mpl::true_ {};
    221221
     
    223223      , typename Context, typename Iterator>
    224224    struct handles_container<karma::strict_list<Left, Right>, Attribute
    225           , Context, Iterator> 
     225          , Context, Iterator>
    226226      : mpl::true_ {};
    227227}}}
  • branches/release/boost/spirit/home/support/attributes.hpp

    r81305 r81797  
    11/*=============================================================================
    22    Copyright (c) 2001-2011 Joel de Guzman
    3     Copyright (c) 2001-2011 Hartmut Kaiser
     3    Copyright (c) 2001-2012 Hartmut Kaiser
    44
    55    Distributed under the Boost Software License, Version 1.0. (See accompanying
     
    521521    };
    522522
     523    namespace detail
     524    {
     525        struct attribute_size_visitor : static_visitor<>
     526        {
     527            template <typename T>
     528            typename attribute_size<T>::type operator()(T const& val) const
     529            {
     530                return spirit::traits::size(val);
     531            }
     532        };
     533    }
     534
     535    template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
     536    struct attribute_size<variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
     537    {
     538        typedef std::size_t type;
     539
     540        static void call(variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& val)
     541        {
     542            apply_visitor(detail::attribute_size_visitor(), val);
     543        }
     544    };
     545
    523546    template <typename Iterator>
    524547    struct attribute_size<iterator_range<Iterator> >
  • branches/release/libs

  • branches/release/libs/spirit

  • branches/release/libs/spirit/classic/doc/multi_pass.html

    r56628 r81797  
    249249<h4>CheckingPolicy</h4>
    250250<p> The CheckingPolicy must have the following interface:</p>
    251 <pre>    <code><span class="keyword">class </span><span class="identifier">my_check<br>    </span><span class="special">{<br>    </span><span class="keyword">protected</span><span class="special">:<br><br>        </span><span class="identifier">my_check</span><span class="special">();<br>        </span><span class="identifier">my_check</span><span class="special">(</span><span class="identifier">my_check </span><span class="keyword">const</span><span class="special">&amp; </span><span class="identifier">x</span><span class="special">);<br>        </span><span class="keyword">void </span><span class="identifier">destroy</span><span class="special">();<br>        </span><span class="keyword">void </span><span class="identifier">swap</span><span class="special">(</span><span class="identifier">my_check</span><span class="special">&amp; </span><span class="identifier">x</span><span class="special">);<br>        </span><span class="comment">// check should make sure that this iterator is valid<br>        </span><span class="keyword">void </span><span class="identifier">check</span><span class="special">() </span><span class="keyword">const</span><span class="special">;<br>        </span><span class="keyword">void </span><span class="identifier">clear_queue</span><span class="special">();<br>    </span><span class="special">};<br></span></code></pre>
     251<pre>    <code><span class="keyword">class </span><span class="identifier">my_check<br>    </span><span class="special">{<br>    </span><span class="keyword">protected</span><span class="special">:<br><br>        </span><span class="identifier">my_check</span><span class="special">();<br>        </span><span class="identifier">my_check</span><span class="special">(</span><span class="identifier">my_check </span><span class="keyword">const</span><span class="special">&amp; </span><span class="identifier">x</span><span class="special">);<br>        </span><span class="keyword">void </span><span class="identifier">destroy</span><span class="special">();<br>        </span><span class="keyword">void </span><span class="identifier">swap</span><span class="special">(</span><span class="identifier">my_check</span><span class="special">&amp; </span><span class="identifier">x</span><span class="special">);<br>        </span><span class="comment">// check should make sure that this iterator is valid<br>        </span><span class="keyword">void </span><span class="identifier">check_if_valid</span><span class="special">() </span><span class="keyword">const</span><span class="special">;<br>        </span><span class="keyword">void </span><span class="identifier">clear_queue</span><span class="special">();<br>    </span><span class="special">};<br></span></code></pre>
    252252<a name="storagepolicy"></a>
    253253<h4>StoragePolicy</h4>
  • branches/release/libs/spirit/doc

  • branches/release/libs/spirit/doc/karma/numeric.qbk

    r71375 r81797  
    876876          `std::numeric_limits<T>::digits10 + 1`.]]
    877877[   [``
    878         template <bool ForceSign,
    879             typename OutputIterator>
     878        template <typename OutputIterator>
    880879        bool integer_part(OutputIterator& sink
    881880          , Num n, bool sign, bool force_sign);
  • branches/release/libs/spirit/doc/what_s_new.qbk

    r76386 r81797  
    11[/==============================================================================
    22    Copyright (C) 2001-2011 Joel de Guzman
    3     Copyright (C) 2001-2011 Hartmut Kaiser
     3    Copyright (C) 2001-2012 Hartmut Kaiser
    44
    55    Distributed under the Boost Software License, Version 1.0. (See accompanying
     
    2828* Fixed __karma__ examples (thanks to Lee Clagett for submitting a patch).
    2929* Fixed #6368: [multi_pass] clear_queue isn't forwarded to the storage policy.
     30* Fixed a problem in __karma__ when a variant holding a container was used as
     31  a generator inside a sequence.
    3032
    3133[endsect]
  • branches/release/libs/spirit/example

  • branches/release/libs/spirit/example/qi/compiler_tutorial/conjure2

  • branches/release/libs/spirit/test

  • branches/release/libs/spirit/test/Jamfile

    r76386 r81797  
    251251     [ run karma/regression_real_scientific.cpp            : : : :  karma_regression_real_scientific ]
    252252     [ run karma/regression_center_alignment.cpp           : : : :  karma_regression_center_alignment ]
     253     [ run karma/regression_container_variant_sequence.cpp : : : :  karma_regression_container_variant_sequence ]
     254     [ run karma/regression_real_0.cpp                     : : : :  karma_regression_real_0 ]
     255     [ run karma/regression_unicode_char.cpp               : : : :  karma_regression_unicode_char ]
    253256
    254257    ;
  • branches/release/libs/spirit/test/qi/alternative.cpp

    r71244 r81797  
    6060struct DIgnore
    6161{
    62         std::string text;
     62    std::string text;
    6363};
    6464
    6565struct DInclude
    6666{
    67         std::string FileName;
     67    std::string FileName;
    6868};
    6969
  • branches/release/libs/spirit/test/support/utree.cpp

    r74359 r81797  
    469469    // tags
    470470    {
    471         short min = std::numeric_limits<short>::min();
    472         short max = std::numeric_limits<short>::max();
     471        short min = (std::numeric_limits<short>::min)();
     472        short max = (std::numeric_limits<short>::max)();
    473473
    474474        utree::list_type u;
Note: See TracChangeset for help on using the changeset viewer.