Changeset 44566


Ignore:
Timestamp:
Apr 19, 2008, 12:38:43 AM (10 years ago)
Author:
Eric Niebler
Message:

Merged revisions 44524-44535,44537-44541,44547,44551,44553-44562 via svnmerge from
https://svn.boost.org/svn/boost/trunk

........

r44524 | djowel | 2008-04-17 16:59:34 -0700 (Thu, 17 Apr 2008) | 1 line


action-dispatch

........

r44525 | djowel | 2008-04-17 17:55:12 -0700 (Thu, 17 Apr 2008) | 1 line


added example on various ways to attach actions

........

r44526 | djowel | 2008-04-17 17:59:39 -0700 (Thu, 17 Apr 2008) | 1 line


action-dispatch tweaks for phoenix special handling

........

r44527 | hkaiser | 2008-04-17 18:11:25 -0700 (Thu, 17 Apr 2008) | 1 line


Spirit: added eol and end parsers.

........

r44528 | hkaiser | 2008-04-17 18:12:10 -0700 (Thu, 17 Apr 2008) | 1 line


Spirit.Lex: Added support for token ids other than std::size_t.

........

r44529 | hkaiser | 2008-04-17 18:39:58 -0700 (Thu, 17 Apr 2008) | 1 line


Spirit.Karma: added simple function support for semantic actions, added example.

........

r44530 | djowel | 2008-04-17 18:49:31 -0700 (Thu, 17 Apr 2008) | 1 line


minor tweaks

........

r44531 | djowel | 2008-04-18 01:33:12 -0700 (Fri, 18 Apr 2008) | 1 line


fixed include

........

r44532 | speedsnail | 2008-04-18 02:53:46 -0700 (Fri, 18 Apr 2008) | 1 line


removed misspelled mimte-type property

........

r44533 | johnmaddock | 2008-04-18 03:03:46 -0700 (Fri, 18 Apr 2008) | 2 lines


Removed command line options that screw up Intel on Darwin.
Added warning suppression to code instead.

........

r44534 | johnmaddock | 2008-04-18 03:14:23 -0700 (Fri, 18 Apr 2008) | 1 line


Update thread tests: allow thread creation to fail at runtime.

........

r44535 | johnmaddock | 2008-04-18 03:15:09 -0700 (Fri, 18 Apr 2008) | 1 line


Apply BOOST_NO_ADL_BARRIER to more Sunpro versions.

........

r44537 | djowel | 2008-04-18 03:32:09 -0700 (Fri, 18 Apr 2008) | 1 line


added actions test + bug fixes

........

r44538 | djowel | 2008-04-18 03:32:40 -0700 (Fri, 18 Apr 2008) | 1 line


added actions test + bug fixes

........

r44539 | djowel | 2008-04-18 04:12:14 -0700 (Fri, 18 Apr 2008) | 1 line


tweaks

........

r44540 | hkaiser | 2008-04-18 05:35:25 -0700 (Fri, 18 Apr 2008) | 1 line


Spirit: changed end parser to be named eoi.

........

r44541 | hkaiser | 2008-04-18 06:52:47 -0700 (Fri, 18 Apr 2008) | 1 line


Spirit.Lex: trying to fix some gcc issues.

........

r44547 | hkaiser | 2008-04-18 09:03:09 -0700 (Fri, 18 Apr 2008) | 1 line


Spirit: Fixed a duplicate header include guard constant

........

r44551 | speedsnail | 2008-04-18 11:11:03 -0700 (Fri, 18 Apr 2008) | 2 lines


relaxed test, ignoring case of drive letter.
Thanks to Mat Marcus for the fix.

........

r44553 | djowel | 2008-04-18 13:05:59 -0700 (Fri, 18 Apr 2008) | 1 line


removed unnecessary stuff

........

r44554 | djowel | 2008-04-18 13:23:21 -0700 (Fri, 18 Apr 2008) | 1 line


added test for function reference; removed test for non-const ref attribute.

........

r44555 | djowel | 2008-04-18 13:23:49 -0700 (Fri, 18 Apr 2008) | 1 line


disallow mutability of attribute in actions

........

r44556 | djowel | 2008-04-18 13:32:43 -0700 (Fri, 18 Apr 2008) | 1 line


tweaks

........

r44557 | djowel | 2008-04-18 13:33:10 -0700 (Fri, 18 Apr 2008) | 1 line


uncommenting failing code (a regression)

........

r44558 | djowel | 2008-04-18 14:03:53 -0700 (Fri, 18 Apr 2008) | 1 line


fixed rule accepting any type of skipper but doing nothing

........

r44559 | djowel | 2008-04-18 14:04:15 -0700 (Fri, 18 Apr 2008) | 1 line


fixed rule accepting any type of skipper but doing nothing

........

r44560 | djowel | 2008-04-18 14:09:11 -0700 (Fri, 18 Apr 2008) | 1 line


fixed rule accepting any type of skipper but doing nothing

........

r44561 | djowel | 2008-04-18 16:41:48 -0700 (Fri, 18 Apr 2008) | 1 line


put virtual_component_base outside detail namespace plus a few renames

........

r44562 | hkaiser | 2008-04-18 17:06:02 -0700 (Fri, 18 Apr 2008) | 1 line


Spirit: Removed testing for compatibility of skipper and delimiter with the rule. Added some comments at the place where the compilation error occurs if skipper of delimiter are incompatible.

........

Location:
branches/proto/v4
Files:
41 edited
6 copied

Legend:

Unmodified
Added
Removed
  • branches/proto/v4

  • branches/proto/v4/boost/config/compiler/sunpro_cc.hpp

    r43914 r44566  
    6868#    if (__SUNPRO_CC <= 0x580)
    6969#      define BOOST_NO_IS_ABSTRACT
    70 #      define BOOST_NO_ADL_BARRIER
    7170#    endif
    7271
     
    7574//
    7675#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
     76#define BOOST_NO_ADL_BARRIER
    7777
    7878
  • branches/proto/v4/boost/iostreams/detail/execute.hpp

    • Property svn:mimte-type deleted
  • branches/proto/v4/boost/iostreams/detail/functional.hpp

    • Property svn:mimte-type deleted
  • branches/proto/v4/boost/spirit/home/karma/action/action.hpp

    r44358 r44566  
    1414#include <boost/spirit/home/support/detail/values.hpp>
    1515#include <boost/spirit/home/support/attribute_of.hpp>
     16#include <boost/spirit/home/support/detail/action_dispatch.hpp>
    1617#include <boost/spirit/home/karma/domain.hpp>
    1718#include <boost/mpl/if.hpp>
     
    6162            // and a bool flag that the client can set to false to
    6263            // fail parsing.
    63             bool pass = true;
    64             spirit::right(component)(
    65                 spirit::detail::pass_value<param_type>::call(p), ctx, pass);
     64            // call the function, passing the attribute, the context.
     65            // The client can return false to fail parsing.
     66            bool pass = spirit::detail::action_dispatch(
     67                spirit::right(component), p, ctx);
    6668
    6769            return pass &&
  • branches/proto/v4/boost/spirit/home/karma/generate.hpp

    r44358 r44566  
    1717#include <boost/mpl/assert.hpp>
    1818#include <boost/mpl/bool.hpp>
    19 
    20 ///////////////////////////////////////////////////////////////////////////
    21 namespace boost { namespace spirit { namespace traits
    22 {
    23     // normally any skipper can be used with any generator
    24     template <typename Generator, typename Delimiter>
    25     struct delimiter_is_compatible : mpl::true_
    26     {
    27     };
    28    
    29     // If the parser is a rule or a grammar, then the delimiter must be
    30     // convertible to the delimiter used with this rule or grammar. The
    31     // corresponding specializations are defined in the files grammar.hpp and
    32     // rule.hpp.
    33 }}}
    3419
    3520///////////////////////////////////////////////////////////////////////////////
     
    10590            delimiter_is_not_convertible_to_a_generator,
    10691            (OutputIterator, Expr, Delimiter));
    107 
    108         typedef spirit::traits::delimiter_is_compatible<Expr, Delimiter>
    109             delimiter_is_compatible;
    110            
    111         BOOST_MPL_ASSERT_MSG(
    112             delimiter_is_compatible::value,
    113             delimiter_is_not_compatible_with_generator,
    114             (OutputIterator, Expr, Delimiter));
    11592       
    11693        // wrap user supplied iterator into our own output iterator
     
    152129            delimiter_is_not_convertible_to_a_generator,
    153130            (OutputIterator, Expr, Parameter, Delimiter));
    154 
    155         typedef spirit::traits::delimiter_is_compatible<Expr, Delimiter>
    156             delimiter_is_compatible;
    157            
    158         BOOST_MPL_ASSERT_MSG(
    159             delimiter_is_compatible::value,
    160             delimiter_is_not_compatible_with_generator,
    161             (OutputIterator, Expr, Parameter, Delimiter));
    162131       
    163132        // wrap user supplied iterator into our own output iterator
  • branches/proto/v4/boost/spirit/home/karma/nonterminal/detail/rule.hpp

    r44358 r44566  
    3737    struct virtual_component_base
    3838    {
    39         struct no_delimiter {};
     39        struct take_no_delimiter {};
    4040
    4141        typedef typename
    4242            mpl::eval_if<
    4343                is_same<Delimiter, unused_type>,
    44                 mpl::identity<no_delimiter>,
     44                mpl::identity<take_no_delimiter>,
    4545                result_of::as_component<karma::domain, Delimiter>
    4646            >::type
     
    206206        base_type;
    207207        typedef typename base_type::delimiter_type delimiter_type;
    208         typedef typename base_type::no_delimiter no_delimiter;
     208        typedef typename base_type::take_no_delimiter take_no_delimiter;
    209209
    210210        virtual_component(Component const& component)
     
    238238
    239239        bool
    240         generate_main(OutputIterator& /*sink*/, Context& /*context*/, no_delimiter,
     240        generate_main(OutputIterator& /*sink*/, Context& /*context*/, take_no_delimiter,
    241241            mpl::false_)
    242242        {
     
    246246
    247247        bool
    248         generate_main(OutputIterator& /*sink*/, Context& /*context*/, no_delimiter,
     248        generate_main(OutputIterator& /*sink*/, Context& /*context*/, take_no_delimiter,
    249249            mpl::true_)
    250250        {
  • branches/proto/v4/boost/spirit/home/karma/nonterminal/grammar.hpp

    r44358 r44566  
    114114}}}
    115115
    116 ///////////////////////////////////////////////////////////////////////////////
    117 namespace boost { namespace spirit { namespace traits
    118 {
    119     // forward declaration only (the default specialization is defined in the
    120     // file generate.hpp)
    121     template <typename Generator, typename Delimiter>
    122     struct delimiter_is_compatible;
    123    
    124     // If the parser is a grammar, then the delimiter must be convertible to
    125     // the delimiter used with this grammar.
    126     template <typename Definition, typename Delimiter>
    127     struct delimiter_is_compatible<karma::grammar<Definition>, Delimiter>
    128       : is_convertible<
    129             Delimiter, typename karma::grammar<Definition>::delimiter_type
    130         >
    131     {
    132     };
    133 
    134 }}}
    135 
    136116#endif
  • branches/proto/v4/boost/spirit/home/karma/nonterminal/rule.hpp

    r44358 r44566  
    160160            OutputIterator_& sink, Context& context, Delimiter const& delim) const
    161161        {
     162            // If the following line produces a compilation error stating the
     163            // 3rd parameter is not convertible to the expected type, then you
     164            // probably trying to use this rule instance with a delimiter which
     165            // is not compatible with the delimiter type used while defining
     166            // the type of this rule instance.
    162167            return ptr->generate(sink, context, delim);
    163168        }
     
    189194}}}
    190195
    191 ///////////////////////////////////////////////////////////////////////////////
    192 namespace boost { namespace spirit { namespace traits
    193 {
    194     // forward declaration only (the default specialization is defined in the
    195     // file generate.hpp)
    196     template <typename Generator, typename Delimiter>
    197     struct delimiter_is_compatible;
    198    
    199     // If the parser is a rule, then the delimiter must be convertible to
    200     // the delimiter used with this rule.
    201     template <
    202         typename OutputIterator, typename T0, typename T1, typename T2,
    203         typename Delimiter
    204     >
    205     struct delimiter_is_compatible<
    206             karma::rule<OutputIterator, T0, T1, T2>, Delimiter>
    207       : is_convertible<
    208             Delimiter,
    209             typename karma::rule<OutputIterator, T0, T1, T2>::delimiter_type
    210         >
    211     {
    212     };
    213 
    214 }}}
    215 
    216196#if defined(BOOST_MSVC)
    217197# pragma warning(pop)
  • branches/proto/v4/boost/spirit/home/lex/lexer/lexer.hpp

    r44358 r44566  
    4848            typedef proto::extends<tag, lexer_def_> base_type;
    4949
     50            typedef typename LexerDef::id_type id_type;
     51           
    5052            tag make_tag() const
    5153            {
     
    6668                typedef typename Iterator::base_iterator_type iterator_type;
    6769                typedef
    68                     fusion::vector<std::size_t, iterator_range<iterator_type> >
     70                    fusion::vector<id_type, iterator_range<iterator_type> >
    6971                type;
    7072            };
     
    8587
    8688                    token_type &t = *first;
    87                     if (0 != t.id()) {
     89                    if (token_is_valid(t)) {
    8890                    // any of the token definitions matched
    8991                        qi::detail::assign_to(t, attr);
     
    110112
    111113                adder const&
    112                 operator()(char_type c, std::size_t token_id = 0) const
     114                operator()(char_type c, id_type token_id = 0) const
    113115                {
    114116                    if (0 == token_id)
    115                         token_id = static_cast<std::size_t>(c);
     117                        token_id = static_cast<id_type>(c);
    116118                    def.def.add_token (def.state.c_str(), lex::detail::escape(c),
    117119                        token_id);
     
    119121                }
    120122                adder const&
    121                 operator()(string_type const& s, std::size_t token_id = 0) const
     123                operator()(string_type const& s, id_type token_id = id_type()) const
    122124                {
    123125                    if (0 == token_id)
    124                         token_id = next_id();
     126                        token_id = next_id<id_type>::get();
    125127                    def.def.add_token (def.state.c_str(), s, token_id);
    126128                    return *this;
     
    128130                template <typename Attribute>
    129131                adder const&
    130                 operator()(token_def<Attribute, char_type>& tokdef,
    131                     std::size_t token_id = 0) const
     132                operator()(token_def<Attribute, char_type, id_type>& tokdef,
     133                    id_type token_id = id_type()) const
    132134                {
    133135                    // make sure we have a token id
    134136                    if (0 == token_id) {
    135137                        if (0 == tokdef.id()) {
    136                             token_id = next_id();
     138                            token_id = next_id<id_type>::get();
    137139                            tokdef.id(token_id);
    138140                        }
     
    279281    ///////////////////////////////////////////////////////////////////////////
    280282    template <typename Lexer>
    281     class lexer_def : noncopyable, public Lexer
     283    class lexer_def : private noncopyable, public Lexer
    282284    {
    283285    private:
    284         typedef lexer_def<Lexer> self_type;
     286        typedef lexer_def self_type;
    285287       
    286288        // avoid warnings about using 'this' in constructor
     
    289291    public:       
    290292        typedef Lexer lexer_type;
     293        typedef typename Lexer::id_type id_type;
    291294        typedef detail::lexer_def_<self_type> token_set;
    292295        typedef typename Lexer::char_type char_type;
     
    318321        typedef typename Definition::char_type char_type;
    319322        typedef typename Definition::iterator_type iterator_type;
     323        typedef typename Definition::id_type id_type;
    320324
    321325        lexer(Definition& token_def_)
  • branches/proto/v4/boost/spirit/home/lex/lexer/lexer_fwd.hpp

    r44358 r44566  
    1818    //  This component represents a token definition
    1919    ///////////////////////////////////////////////////////////////////////////
    20     template<typename Attribute = unused_type, typename Char = char>
     20    template<typename Attribute = unused_type, typename Char = char,
     21        typename Idtype = std::size_t>
    2122    class token_def;
    2223
  • branches/proto/v4/boost/spirit/home/lex/lexer/lexertl/lexertl_lexer.hpp

    r44523 r44566  
    8484
    8585    public:
     86        typedef Token token_type;
     87        typedef typename Token::id_type id_type;
     88
    8689        // interface for token definition management
    8790        void add_token (char_type const* state, string_type const& tokendef,
     
    193196        //  a public interface .
    194197        typedef Token token_type;
     198        typedef typename Token::id_type id_type;
    195199        typedef TokenSet token_set;
    196200        typedef lexertl_iterator<Functor> iterator_type;
    197        
     201
     202    private:
     203        // this type is purely used for the iterator_type construction below
     204        struct iterator_data_type {
     205            boost::lexer::state_machine const& state_machine_;
     206            boost::lexer::basic_rules<char_type> const& rules_;
     207            typename Functor::semantic_actions_type const& actions_;
     208        };
     209
     210    public:
    198211        //  Return the start iterator usable for iterating over the generated
    199212        //  tokens.
     
    203216                return iterator_type();
    204217               
    205             struct iterator_data_type {
    206                 boost::lexer::state_machine const& state_machine_;
    207                 boost::lexer::basic_rules<char_type> const& rules_;
    208                 typename Functor::semantic_actions_type const& actions_;
    209             };
    210 
    211218            iterator_data_type iterator_data = { state_machine, rules, actions };
    212219            return iterator_type(iterator_data, first, last);
  • branches/proto/v4/boost/spirit/home/lex/lexer/lexertl/lexertl_static_lexer.hpp

    r44358 r44566  
    170170        typedef TokenSet token_set;
    171171        typedef lexertl_iterator<Functor> iterator_type;
    172        
     172
     173    private:       
     174        // this type is purely used for the iterator_type construction below
     175        struct iterator_data_type {
     176            typename Functor::next_token_functor next_;
     177            typename Functor::semantic_actions_type const& actions_;
     178        };
     179
     180    public:
    173181        //  Return the start iterator usable for iterating over the generated
    174182        //  tokens, the Functor F is called to match the next token from the
     
    177185        iterator_type begin(Iterator& first, Iterator const& last, F next) const
    178186        {
    179             struct iterator_data_type {
    180                 typename Functor::next_token_functor next_;
    181                 typename Functor::semantic_actions_type const& actions_;
    182             };
    183 
    184187            iterator_data_type iterator_data = { next, actions };
    185188            return iterator_type(iterator_data, first, last);
     
    192195        iterator_type begin(Iterator_& first, Iterator_ const& last) const
    193196        {
    194             struct iterator_data_type {
    195                 typename Functor::next_token_functor next_;
    196                 typename Functor::semantic_actions_type const& actions_;
    197             };
    198 
    199197            iterator_data_type iterator_data =
    200198                { &lex::static_::next_token<Iterator_>, actions };
  • branches/proto/v4/boost/spirit/home/lex/lexer/lexertl/lexertl_token.hpp

    r44523 r44566  
    5454    //                        underlying character stream.
    5555    //
     56    //        id_type         The type of the token id used.
     57    //
    5658    //    methods
    5759    //        default constructor
     
    108110        typedef Iterator iterator_type;
    109111        typedef mpl::false_ has_state;
     112        typedef std::size_t id_type;
    110113       
    111114        //  default constructed tokens correspond to EOI tokens
  • branches/proto/v4/boost/spirit/home/lex/lexer/meta_grammar.hpp

    r44358 r44566  
    1313
    1414#include <boost/spirit/home/lex/domain.hpp>
     15#include <boost/spirit/home/lex/lexer/lexer_fwd.hpp>
    1516#include <boost/spirit/home/lex/lexer/terminal_holder.hpp>
    1617#include <boost/spirit/home/support/placeholders.hpp>
     
    3031    struct char_token_def;
    3132   
    32     template<typename Attribute, typename Char>
    33     class token_def;
    34 
    35     template <typename TokenSet>
    36     class token_set;
    37 
    3833    struct lexer_meta_grammar;
    3934
     
    5348            meta_grammar::terminal_rule<
    5449                lex::domain,
    55                 terminal_holder<proto::_, lex::token_def<proto::_, proto::_> >,
     50                terminal_holder<proto::_, lex::token_def<proto::_, proto::_, proto::_> >,
    5651                terminal_director
    5752            >,
  • branches/proto/v4/boost/spirit/home/lex/lexer/string_token_def.hpp

    r44358 r44566  
    2828            String const& state)
    2929        {
    30             lexdef.add_token (state.c_str(), subject(component), next_id());
     30            typedef typename LexerDef::id_type id_type;
     31            lexdef.add_token (state.c_str(), subject(component),
     32                next_id<id_type>::get());
    3133        }
    3234    };
  • branches/proto/v4/boost/spirit/home/lex/lexer/token_def.hpp

    r44358 r44566  
    3535   
    3636    ///////////////////////////////////////////////////////////////////////////
    37     inline std::size_t next_id()
     37    //  The next_id template needs to be specialized for any non-default token
     38    //  id type used by a custom token type. It need to expose a function
     39    //  'static Idtype get()' returning the next available token id each time
     40    //  it is called.
     41    template <typename Idtype>
     42    struct next_id;
     43   
     44    ///////////////////////////////////////////////////////////////////////////
     45    //  Default specialization for the next_id template returning the next
     46    //  available token id.
     47    template <>
     48    struct next_id<std::size_t>
    3849    {
    39         static std::size_t next_token_id = min_token_id;
    40         return next_token_id++;   
    41     }
    42 
     50        static std::size_t get()
     51        {
     52            static std::size_t next_token_id = min_token_id;
     53            return next_token_id++;   
     54        }
     55    };
     56   
    4357    ///////////////////////////////////////////////////////////////////////////
    4458    //  This component represents a token definition
    4559    ///////////////////////////////////////////////////////////////////////////
    46     template<typename Attribute, typename Char>
     60    template<typename Attribute, typename Char, typename Idtype>
    4761    class token_def
    4862      : public proto::extends<
    4963            typename make_terminal_holder<
    50                 token_def<Attribute, Char>*, token_def<Attribute, Char>
     64                token_def<Attribute, Char, Idtype>*,
     65                token_def<Attribute, Char, Idtype>
    5166            >::type,
    52             token_def<Attribute, Char>
     67            token_def<Attribute, Char, Idtype>
    5368        >
    5469    {
     
    133148            token_state = lexdef.add_state(state.c_str());
    134149            if (0 == token_id)
    135                 token_id = next_id();
     150                token_id = next_id<Idtype>::get();
    136151            lexdef.add_token (state.c_str(), def, token_id);
    137152        }
     
    139154    public:
    140155        typedef Char char_type;
     156        typedef Idtype id_type;
    141157        typedef std::basic_string<char_type> string_type;
    142158       
     
    145161          : base_type(make_tag()), token_id(0), token_state(~0)
    146162        {}
    147         explicit token_def(char_type def_, std::size_t id_ = 0)
     163        explicit token_def(char_type def_, Idtype id_ = Idtype())
    148164          : base_type(make_tag()), def(lex::detail::escape(def_)),
    149165            token_id(0 == id_ ? def_ : id_), token_state(~0)
    150166        {}
    151         explicit token_def(string_type def_, std::size_t id_ = 0)
     167        explicit token_def(string_type def_, Idtype id_ = Idtype())
    152168          : base_type(make_tag()), def(def_), token_id(id_), token_state(~0)
    153169        {}
     
    168184       
    169185        // general accessors
    170         std::size_t id() const { return token_id; }
    171         void id(std::size_t id) { token_id = id; }
     186        Idtype id() const { return token_id; }
     187        void id(Idtype id) { token_id = id; }
    172188        string_type const& definition() const { return def; }
    173189        std::size_t state() const { return token_state; }
     
    175191    private:
    176192        string_type def;
    177         std::size_t token_id;
     193        Idtype token_id;
    178194        std::size_t token_state;
    179195    };
  • branches/proto/v4/boost/spirit/home/lex/lexer/token_set.hpp

    r44358 r44566  
    4343        token_set& this_() { return *this; }
    4444
    45         typedef token_set<TokenSet> self_type;
     45        typedef token_set self_type;
    4646        typedef TokenSet base_token_set;
    4747
     
    5858
    5959    public:
     60        typedef typename TokenSet::id_type id_type;
     61       
    6062        // Qi interface: metafunction calculating parser return type
    6163        template <typename Component, typename Context, typename Iterator>
     
    6668            typedef typename Iterator::base_iterator_type iterator_type;
    6769            typedef
    68                 fusion::vector<std::size_t, iterator_range<iterator_type> >
     70                fusion::vector<id_type, iterator_range<iterator_type> >
    6971            type;
    7072        };
     
    8991
    9092                token_type &t = *first;
    91                 if (0 != t.id() && token_state == t.state()) {
     93                if (token_is_valid(t) && token_state == t.state()) {
    9294                // any of the token definitions matched
    9395                    qi::detail::assign_to(t, attr);
     
    124126
    125127            adder const&
    126             operator()(char_type c, std::size_t token_id = 0) const
     128            operator()(char_type c, id_type token_id = id_type()) const
    127129            {
    128130                if (0 == token_id)
     
    133135            }
    134136            adder const&
    135             operator()(string_type const& s, std::size_t token_id = 0) const
     137            operator()(string_type const& s, id_type token_id = id_type()) const
    136138            {
    137139                if (0 == token_id)
    138                     token_id = next_id();
     140                    token_id = next_id<id_type>::get();
    139141                def.add_token (def.initial_state().c_str(), s, token_id);
    140142                return *this;
     
    142144            template <typename Attribute>
    143145            adder const&
    144             operator()(token_def<Attribute, char_type>& tokdef,
    145                 std::size_t token_id = 0) const
     146            operator()(token_def<Attribute, char_type, id_type>& tokdef,
     147                id_type token_id = id_type()) const
    146148            {
    147149                // make sure we have a token id
    148150                if (0 == token_id) {
    149151                    if (0 == tokdef.id()) {
    150                         token_id = next_id();
     152                        token_id = next_id<id_type>::get();
    151153                        tokdef.id(token_id);
    152154                    }
  • branches/proto/v4/boost/spirit/home/qi/action/action.hpp

    r44358 r44566  
    1111#include <boost/spirit/home/support/component.hpp>
    1212#include <boost/spirit/home/support/attribute_of.hpp>
    13 #include <boost/spirit/home/support/detail/values.hpp>
     13#include <boost/spirit/home/support/detail/action_dispatch.hpp>
    1414#include <boost/mpl/if.hpp>
    1515#include <boost/mpl/identity.hpp>
     
    3232        {
    3333        };
     34
     35        template <typename F, typename Attribute, typename Context>
     36        static bool const_action_dispatch(
     37            F const& f, Attribute const& attr, Context& context)
     38        {
     39            // This function makes Attribute a const reference
     40            // before calling detail::action_dispatch whereby
     41            // disallowing mutability of the attribute in semantic
     42            // actions.
     43            return spirit::detail::action_dispatch(f, attr, context);
     44        }
    3445
    3546        template <
     
    6172                spirit::left(component), first, last, context, skipper, attr))
    6273            {
    63                 // call the function, passing the attribute, the context
    64                 // and a bool flag that the client can set to false to
    65                 // fail parsing.
    66                 bool pass = true;
    67                 spirit::right(component)(
    68                     spirit::detail::pass_value<attr_type>::call(attr), context, pass);
    69                 return pass;
     74                // call the function, passing the attribute, the context.
     75                // The client can return false to fail parsing.
     76                return const_action_dispatch(
     77                    spirit::right(component), attr, context);
    7078            }
    7179            return false;
  • branches/proto/v4/boost/spirit/home/qi/char.hpp

    r44358 r44566  
    1111#include <boost/spirit/home/qi/char/char.hpp>
    1212#include <boost/spirit/home/qi/char/char_class.hpp>
     13#include <boost/spirit/home/qi/char/primitives.hpp>
    1314#include <boost/spirit/home/qi/char/meta_grammar.hpp>
    1415
  • branches/proto/v4/boost/spirit/home/qi/char/detail/basic_chset.hpp

    r44523 r44566  
    4949        clear(Char from, Char to)
    5050        {
    51             rr.set(range<Char>(c, c));
     51            rr.clear(range<Char>(from, to));
    5252        }
    5353
     
    5555        clear(Char c)
    5656        {
    57             rr.clear(range<Char>(from, to));
     57            rr.clear(range<Char>(c, c));
    5858        }
    5959
  • branches/proto/v4/boost/spirit/home/qi/char/meta_grammar.hpp

    r44523 r44566  
    6565    struct char_class;
    6666
     67    struct eol_director;
     68    struct eoi_director;
     69   
    6770    ///////////////////////////////////////////////////////////////////////////
    6871    struct char_meta_grammar;
     
    339342              , char_class<mpl::_>
    340343            >
     344          , meta_grammar::terminal_rule<qi::domain, tag::eol, eol_director>
     345          , meta_grammar::terminal_rule<qi::domain, tag::eoi, eoi_director>
    341346        >
    342347    {};
  • branches/proto/v4/boost/spirit/home/qi/debug/detail/debug_handler.hpp

    r44358 r44566  
    99#define BOOST_SPIRIT_DEBUG_HANDLER_NOV_12_2007_0926AM
    1010
    11 #include <boost/spirit/home/qi/nonterminal/detail/rule.hpp>
     11#include <boost/spirit/home/qi/nonterminal/virtual_component_base.hpp>
    1212
    1313namespace boost { namespace spirit { namespace qi { namespace debug
     
    2727    struct trace_level
    2828    {
    29         trace_level(int &level) 
    30           : level(level) 
     29        trace_level(int &level)
     30          : level(level)
    3131        {
    3232            ++level;
     
    3636            --level;
    3737        }
    38        
     38
    3939        int& level;
    4040    };
    41    
     41
    4242    ///////////////////////////////////////////////////////////////////////////
    4343    template <
     
    4545        typename PreParseF, typename PostParseF
    4646    >
    47     struct debug_handler 
    48       : qi::detail::virtual_component_base<Iterator, Context, Skipper>
     47    struct debug_handler
     48      : virtual_component_base<Iterator, Context, Skipper>
    4949    {
    50         typedef 
    51             qi::detail::virtual_component_base<Iterator, Context, Skipper>
     50        typedef
     51            virtual_component_base<Iterator, Context, Skipper>
    5252        base_type;
    5353        typedef intrusive_ptr<base_type> pointer_type;
     
    5656        debug_handler(pointer_type subject, std::string const& name,
    5757                bool trace, PreParseF preF, PostParseF postF)
    58           : subject(subject), name(name), trace(trace), 
     58          : subject(subject), name(name), trace(trace),
    5959            preF(preF), postF(postF)
    6060        {
     
    6868          , Skipper_ const& skipper)
    6969        {
    70             // execute embedded parser if tracing is disabled or if the 
     70            // execute embedded parser if tracing is disabled or if the
    7171            // pre-parse hook returns true
    7272            bool r = false;
    73             if (!trace || preF(name, subject, get_trace_level(), first, last)) 
     73            if (!trace || preF(name, subject, get_trace_level(), first, last))
    7474            {
    7575                {
    7676                    trace_level level(get_trace_level());
    77                    
     77
    7878                    // do the actual parsing
    7979                    Iterator i = first;
     
    8282                        first = i;
    8383                }
    84                                    
     84
    8585                // the post-parse hook gets executed only if tracing is enabled
    8686                if (trace)
     
    105105          , Iterator const& last
    106106          , Context& context
    107           , unused_type)
     107          , no_skipper)
    108108        {
    109109            return parse_main(first, last, context, unused);
     
    116116        PostParseF postF;
    117117    };
    118  
    119 }   
     118
     119}
    120120}}}}
    121121
  • branches/proto/v4/boost/spirit/home/qi/nonterminal/detail/error_handler.hpp

    r44358 r44566  
    88#define BOOST_SPIRIT_ERROR_HANDLER_APR_29_2007_1042PM
    99
    10 #include <boost/spirit/home/qi/nonterminal/detail/rule.hpp>
     10#include <boost/spirit/home/qi/nonterminal/virtual_component_base.hpp>
    1111#include <boost/spirit/home/qi/nonterminal/error_handler_result.hpp>
    1212#include <boost/spirit/home/qi/operator/expect.hpp>
     
    8888          , Iterator const& last
    8989          , Context& context
    90           , unused_type)
     90          , no_skipper)
    9191        {
    9292            return parse_main(first, last, context, unused);
  • branches/proto/v4/boost/spirit/home/qi/nonterminal/detail/rule.hpp

    r44358 r44566  
    88#define BOOST_SPIRIT_RULE_FEB_12_2007_0440PM
    99
    10 #include <boost/spirit/home/support/unused.hpp>
    11 #include <boost/spirit/home/support/component.hpp>
    12 #include <boost/intrusive_ptr.hpp>
    13 #include <boost/detail/atomic_count.hpp>
    14 #include <boost/mpl/eval_if.hpp>
    15 #include <boost/mpl/identity.hpp>
    16 #include <boost/type_traits/is_same.hpp>
    17 #include <boost/utility/enable_if.hpp>
    18 #include <boost/function_types/is_function.hpp>
     10#include <boost/spirit/home/qi/nonterminal/virtual_component_base.hpp>
    1911#include <boost/assert.hpp>
    20 #include <algorithm>
    2112
    2213namespace boost { namespace spirit { namespace qi { namespace detail
    2314{
    24     template <typename Iterator, typename Context, typename Skipper>
    25     struct virtual_component_base
    26     {
    27         struct no_skipper {};
    28 
    29         typedef typename
    30             mpl::eval_if<
    31                 is_same<Skipper, unused_type>
    32               , mpl::identity<no_skipper>
    33               , result_of::as_component<qi::domain, Skipper>
    34             >::type
    35         skipper_type;
    36 
    37         virtual_component_base()
    38           : use_count(0)
    39         {
    40         }
    41 
    42         virtual ~virtual_component_base()
    43         {
    44         }
    45 
    46         virtual bool
    47         parse(
    48             Iterator& first
    49           , Iterator const& last
    50           , Context& context
    51           , skipper_type const& skipper) = 0;
    52 
    53         virtual bool
    54         parse(
    55             Iterator& first
    56           , Iterator const& last
    57           , Context& context
    58           , unused_type) = 0;
    59 
    60         boost::detail::atomic_count use_count;
    61     };
    62 
    63     template <typename Iterator, typename Context, typename Skipper>
    64     inline void
    65     intrusive_ptr_add_ref(virtual_component_base<Iterator, Context, Skipper>* p)
    66     {
    67         ++p->use_count;
    68     }
    69 
    70     template <typename Iterator, typename Context, typename Skipper>
    71     inline void
    72     intrusive_ptr_release(virtual_component_base<Iterator, Context, Skipper>* p)
    73     {
    74         if (--p->use_count == 0)
    75             delete p;
    76     }
    77 
    7815    template <
    7916        typename Iterator, typename Component
     
    8522        typedef virtual_component_base<Iterator, Context, Skipper> base_type;
    8623        typedef typename base_type::skipper_type skipper_type;
    87         typedef typename base_type::no_skipper no_skipper;
     24        typedef typename base_type::take_no_skipper take_no_skipper;
    8825
    8926        virtual_component(Component const& component)
     
    15289          , Iterator const& /*last*/
    15390          , Context&
    154           , no_skipper
     91          , take_no_skipper
    15592          , mpl::false_)
    15693        {
     
    163100          , Iterator const& /*last*/
    164101          , Context& /*context*/
    165           , no_skipper
     102          , take_no_skipper
    166103          , mpl::true_)
    167104        {
     
    185122          , Iterator const& last
    186123          , Context& context
    187           , unused_type)
     124          , no_skipper)
    188125        {
    189126            return parse_main(first, last, context, unused, Auto());
  • branches/proto/v4/boost/spirit/home/qi/nonterminal/grammar.hpp

    r44358 r44566  
    124124}}}
    125125
    126 ///////////////////////////////////////////////////////////////////////////////
    127 namespace boost { namespace spirit { namespace traits
    128 {
    129     // forward declaration only (the default specialization is defined in the
    130     // file parse.hpp)
    131     template <typename Parser, typename Skipper>
    132     struct skipper_is_compatible;
    133    
    134     // If the parser is a grammar, then the skipper must be convertible to
    135     // the skipper used with this grammar.
    136     template <typename Definition, typename Skipper>
    137     struct skipper_is_compatible<qi::grammar<Definition>, Skipper>
    138       : is_convertible<Skipper, typename qi::grammar<Definition>::skipper_type>
    139     {
    140     };
    141 
    142 }}}
    143 
    144126#endif
  • branches/proto/v4/boost/spirit/home/qi/nonterminal/rule.hpp

    r44358 r44566  
    4848
    4949        typedef
    50             detail::virtual_component_base<
     50            virtual_component_base<
    5151                Iterator
    5252              , typename base_type::context_type
     
    169169          , Context& context, Skipper const& skipper) const
    170170        {
     171            // If the following line produces a compilation error stating the
     172            // 4th parameter is not convertible to the expected type, then you
     173            // probably trying to use this rule instance with a skipper which
     174            // is not compatible with the skipper type used while defining the
     175            // type of this rule instance.
    171176            return ptr->parse(first, last, context, skipper);
    172177        }
     
    210215            {
    211216                typename Rule::pointer_type old (r.ptr);
    212                 r.ptr.reset(new Decorator(r.ptr, a1));
     217            r.ptr.reset(new Decorator(r.ptr, a1));
    213218                return old;
    214219            }
     
    357362}}}
    358363
    359 ///////////////////////////////////////////////////////////////////////////////
    360 namespace boost { namespace spirit { namespace traits
    361 {
    362     // forward declaration only
    363     template <typename Parser, typename Skipper>
    364     struct skipper_is_compatible;
    365    
    366     // If the parser is a rule, then the skipper must be convertible to
    367     // the skipper used with this rule.
    368     template <
    369         typename Iterator, typename T0, typename T1, typename T2,
    370         typename Skipper
    371     >
    372     struct skipper_is_compatible<qi::rule<Iterator, T0, T1, T2>, Skipper>
    373       : is_convertible<
    374             Skipper, typename qi::rule<Iterator, T0, T1, T2>::skipper_type
    375         >
    376     {
    377     };
    378 
    379 }}}
    380 
    381364#if defined(BOOST_MSVC)
    382365# pragma warning(pop)
  • branches/proto/v4/boost/spirit/home/qi/parse.hpp

    r44523 r44566  
    1313#include <boost/mpl/assert.hpp>
    1414#include <boost/mpl/bool.hpp>
    15 
    16 ///////////////////////////////////////////////////////////////////////////
    17 namespace boost { namespace spirit { namespace traits
    18 {
    19     // normally any skipper can be used with any parser
    20     template <typename Parser, typename Skipper>
    21     struct skipper_is_compatible : mpl::true_
    22     {
    23     };
    24    
    25     // If the parser is a rule or a grammar, then the skipper must be
    26     // convertible to the skipper used with this rule or grammar. The
    27     // corresponding specializations are defined in the files grammar.hpp and
    28     // rule.hpp.
    29 }}}
    3015
    3116namespace boost { namespace spirit { namespace qi
     
    9378            skipper_is_not_convertible_to_a_parser, (Iterator, Expr, Skipper));
    9479
    95         typedef spirit::traits::skipper_is_compatible<Expr, Skipper>
    96             skipper_is_compatible;
    97            
    98         BOOST_MPL_ASSERT_MSG(
    99             skipper_is_compatible::value,
    100             skipper_is_not_compatible_with_parser, (Iterator, Expr, Skipper));
    101        
    10280        typedef typename result_of::as_component<qi::domain, Expr>::type component;
    10381        typedef typename component::director director;
     
    138116            (Iterator, Expr, Attr, Skipper));
    139117
    140         typedef spirit::traits::skipper_is_compatible<Expr, Skipper>
    141             skipper_is_compatible;
    142            
    143         BOOST_MPL_ASSERT_MSG(
    144             skipper_is_compatible::value,
    145             skipper_is_not_compatible_with_parser,
    146             (Iterator, Expr, Attr, Skipper));
    147        
    148118        typedef typename result_of::as_component<qi::domain, Expr>::type component;
    149119        typedef typename component::director director;
  • branches/proto/v4/boost/spirit/home/support/iterators/detail/multi_pass.hpp

    r44523 r44566  
    1313#include <iterator>
    1414#include <algorithm>
    15 
    16 ///////////////////////////////////////////////////////////////////////////////
    17 namespace boost { namespace spirit
    18 {
    19     // forward declaration only
    20     template <typename T, typename Policies>
    21     void swap(multi_pass<T, Policies> &x, multi_pass<T, Policies> &y);
    22 }}
    2315
    2416///////////////////////////////////////////////////////////////////////////////
  • branches/proto/v4/boost/spirit/home/support/iterators/multi_pass_fwd.hpp

    r44358 r44566  
    66    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
    77=============================================================================*/
    8 #if !defined(BOOST_SPIRIT_ITERATOR_MULTI_PASS_FWD_HPP)
    9 #define BOOST_SPIRIT_ITERATOR_MULTI_PASS_FWD_HPP
     8#if !defined(BOOST_SPIRIT_ITERATOR_MULTI_PASS_FWD_APR_18_2008_1102AM)
     9#define BOOST_SPIRIT_ITERATOR_MULTI_PASS_FWD_APR_18_2008_1102AM
    1010
    1111#include <cstddef>
  • branches/proto/v4/boost/spirit/home/support/placeholders.hpp

    r44358 r44566  
    2424        struct lit {};
    2525        struct wlit {};
     26        struct eol {};
     27        struct eoi {};
    2628
    2729        struct bin {};
     
    8183    typedef proto::terminal<tag::lit>::type lit_type;
    8284    typedef proto::terminal<tag::wlit>::type wlit_type;
     85    typedef proto::terminal<tag::eol>::type eol_type;
     86    typedef proto::terminal<tag::eoi>::type end_type;
    8387   
    8488    typedef proto::terminal<tag::bin>::type bin_type;
     
    137141    proto::terminal<tag::lit>::type const lit = {{}};
    138142    proto::terminal<tag::wlit>::type const wlit = {{}};
     143    proto::terminal<tag::eol>::type const eol = {{}};
     144    proto::terminal<tag::eoi>::type const eoi = {{}};
    139145   
    140146    proto::terminal<tag::bin>::type const bin = {{}};
     
    198204    {
    199205        (void) char_; (void) wchar; (void) lit; (void) wlit;
     206        (void) eol; (void) eoi;
    200207        (void) bin; (void) oct; (void) hex;
    201208        (void) byte; (void) word; (void) dword;
  • branches/proto/v4/boost/spirit/phoenix.hpp

    r44355 r44566  
    1111
    1212#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__DMC__)
    13 #  pragma message ("Warning: This header is deprecated. Please use: boost/spirit/include/classic_phoenix.hpp")
     13#  pragma message ("Warning: This header is deprecated. Please use: boost/spirit/include/phoenix1.hpp")
    1414#elif defined(__GNUC__) || defined(__HP_aCC) || defined(__SUNPRO_CC) || defined(__IBMCPP__)
    15 #  warning "This header is deprecated. Please use: boost/spirit/include/classic_phoenix.hpp"
     15#  warning "This header is deprecated. Please use: boost/spirit/include/phoenix1.hpp"
    1616#endif
    1717
     
    1919#define BOOST_SPIRIT_USE_OLD_NAMESPACE
    2020#endif
    21 #include <boost/spirit/include/classic_phoenix.hpp>
     21#include <boost/spirit/include/phoenix1.hpp>
    2222
    2323#endif
  • branches/proto/v4/libs/config/test/boost_has_pthreads.ipp

    r44451 r44566  
    2626   if(0 == result)
    2727   {
     28      //
     29      // Failure to be able to create and use a mutex
     30      // is always a failure, even if the pthread
     31      // library is just a non-functioning stub.
     32      //
    2833      result |= pthread_mutex_lock(&mut);
    2934      result |= pthread_mutex_unlock(&mut);
     
    3237      result |= pthread_mutex_destroy(&mut);
    3338      //
    34       // Check that we can actually create a thread:
     39      // Try and create a thread, this is allowed
     40      // to fail, in case we are linking to a pthread
     41      // "stub" library.
    3542      //
    3643      pthread_t t;
    3744      int r = pthread_create(&t, 0, &thread_proc, 0);
    38       result |= r;
     45      // result |= r;
    3946      if(r == 0)
    4047      {
     48         //
     49         // If we can create a thread, then we must be able to join to it:
     50         //
    4151         void* arg;
    4252         r = pthread_join(t, &arg);
  • branches/proto/v4/libs/math/test/Jamfile.v2

    r44451 r44566  
    1414      <toolset>darwin:<cxxflags>-Wno-missing-braces
    1515      <toolset>acc:<cxxflags>+W2068,2461,2236,4070,4069
    16       <toolset>intel:<cxxflags>-Qwd264
    17       <toolset>intel:<cxxflags>-Qwd239
    18       <toolset>intel:<cxxflags>/nologo
    19       <toolset>intel-linux:<cxxflags>-wd239
    20       <toolset>intel:<linkflags>/nologo
     16      <toolset>intel:<cxxflags>-nologo
     17      <toolset>intel:<linkflags>-nologo
    2118      <toolset>msvc:<warnings>all
    2219      <toolset>msvc:<asynch-exceptions>on
     
    493490
    494491
     492
     493
  • branches/proto/v4/libs/math/test/handle_test_result.hpp

    r40083 r44566  
    1212#include <boost/regex.hpp>
    1313#include <boost/test/test_tools.hpp>
     14
     15#if defined(BOOST_INTEL)
     16#  pragma warning(disable:239)
     17#  pragma warning(disable:264)
     18#endif
    1419
    1520//
  • branches/proto/v4/libs/spirit/example/qi/Jamfile

    r44360 r44566  
    77project spirit-qi-example ;
    88
     9exe actions : actions.cpp ;
    910exe sum : sum.cpp ;
    1011exe complex_number : complex_number.cpp ;
  • branches/proto/v4/libs/spirit/test/Jamfile

    r44360 r44566  
    1515
    1616    # run Qi tests
     17    [ run qi/actions.cpp                    : : : : ]
    1718    [ run qi/char.cpp                       : : : : ]
    1819    [ run qi/char_class.cpp                 : : : : ]
  • branches/proto/v4/libs/spirit/test/qi/char.cpp

    r44523 r44566  
    2424    using boost::spirit::char_;
    2525    using boost::spirit::wchar;
    26 
     26    using boost::spirit::eol;
     27    using boost::spirit::eoi;
     28   
    2729    {
    2830        BOOST_TEST(test("x", 'x'));
     
    116118    }
    117119
     120    {   // eol
     121        BOOST_TEST(test("\r", eol));
     122        BOOST_TEST(test("\r\n", eol));
     123        BOOST_TEST(test("\n", eol));
     124        BOOST_TEST(!test("\b", eol));
     125
     126        BOOST_TEST(test("   \r", eol, char_(' ')));
     127        BOOST_TEST(test("   \r\n", eol, char_(' ')));
     128        BOOST_TEST(test("   \n", eol, char_(' ')));
     129        BOOST_TEST(!test("   \b", eol, char_(' ')));
     130
     131        BOOST_TEST(test(L"\r", eol));
     132        BOOST_TEST(test(L"\r\n", eol));
     133        BOOST_TEST(test(L"\n", eol));
     134        BOOST_TEST(!test(L"\b", eol));
     135
     136        BOOST_TEST(test(L"   \r", eol, wchar(L' ')));
     137        BOOST_TEST(test(L"   \r\n", eol, wchar(L' ')));
     138        BOOST_TEST(test(L"   \n", eol, wchar(L' ')));
     139        BOOST_TEST(!test(L"   \b", eol, wchar(L' ')));
     140    }
     141   
     142    {   // eoi
     143        BOOST_TEST(test("", eoi));
     144        BOOST_TEST(!test("a", eoi));
     145
     146        BOOST_TEST(test("   ", eoi, space));
     147        BOOST_TEST(!test("   a", eoi, space));
     148    }
     149   
    118150    return boost::report_errors();
    119151}
  • branches/proto/v4/libs/spirit/test/qi/grammar_fail.cpp

    r44360 r44566  
    3434    char const* input = "some input, it doesn't matter";
    3535    char const* end = &input[strlen(input)+1];
    36    
     36
    3737    num_list def;
    3838    bool r = phrase_parse(input, end, make_parser(def),
    39                     space | ('%' >> *~char_('\n') >> '\n'));
     39        space | ('%' >> *~char_('\n') >> '\n'));
    4040
    4141    return 0;
  • branches/proto/v4/libs/spirit/test/qi/rule_fail.cpp

    r44360 r44566  
    2121    char const* input = "some input, it doesn't matter";
    2222    char const* end = &input[strlen(input)+1];
    23    
     23
    2424    rule<char const*, rule<char const*> > def;
    2525    def = int_ >> *(',' >> int_);
    26    
     26
    2727    bool r = phrase_parse(input, end, def,
    28                     space | ('%' >> *~char_('\n') >> '\n'));
     28        space | ('%' >> *~char_('\n') >> '\n'));
    2929
    3030    return 0;
  • branches/proto/v4/tools/jam/src/expand.c

    r39336 r44566  
    750750    assert(list_next(l) == 0);
    751751    # ifdef OS_CYGWIN
    752     assert( !strcmp( l->string, "c:\\foo\\bar" ) );
     752    /* On some installations of cygwin the drive letter is expanded to other case. */
     753    /* This has been reported to be the case if cygwin has been installed to C:\   */
     754    /* as opposed to C:\cygwin                                                     */
     755    /* Since case of the drive letter will not matter, we allow for both.          */
     756    assert( 0 == strcmp( l->string, "c:\\foo\\bar" )
     757              || 0 == strcmp( l->string, "C:\\foo\\bar") );
    753758    # else
    754759    assert( !strcmp( l->string, cygpath ) );
Note: See TracChangeset for help on using the changeset viewer.