/src/contrib/boost/spirit/home/classic/utility/impl/chset_operators.ipp

  1/*=============================================================================
  2    Copyright (c) 2001-2003 Joel de Guzman
  3    http://spirit.sourceforge.net/
  4
  5    Use, modification and distribution is subject to the Boost Software
  6    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
  7    http://www.boost.org/LICENSE_1_0.txt)
  8=============================================================================*/
  9#ifndef BOOST_SPIRIT_CHSET_OPERATORS_IPP
 10#define BOOST_SPIRIT_CHSET_OPERATORS_IPP
 11
 12///////////////////////////////////////////////////////////////////////////////
 13#include <boost/limits.hpp>
 14
 15///////////////////////////////////////////////////////////////////////////////
 16namespace boost { namespace spirit {
 17
 18BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
 19
 20///////////////////////////////////////////////////////////////////////////////
 21//
 22//  chset free operators implementation
 23//
 24///////////////////////////////////////////////////////////////////////////////
 25template <typename CharT>
 26inline chset<CharT>
 27operator|(chset<CharT> const& a, chset<CharT> const& b)
 28{
 29    return chset<CharT>(a) |= b;
 30}
 31
 32//////////////////////////////////
 33template <typename CharT>
 34inline chset<CharT>
 35operator-(chset<CharT> const& a, chset<CharT> const& b)
 36{
 37    return chset<CharT>(a) -= b;
 38}
 39
 40//////////////////////////////////
 41template <typename CharT>
 42inline chset<CharT>
 43operator~(chset<CharT> const& a)
 44{
 45    return chset<CharT>(a).inverse();
 46}
 47
 48//////////////////////////////////
 49template <typename CharT>
 50inline chset<CharT>
 51operator&(chset<CharT> const& a, chset<CharT> const& b)
 52{
 53    return chset<CharT>(a) &= b;
 54}
 55
 56//////////////////////////////////
 57template <typename CharT>
 58inline chset<CharT>
 59operator^(chset<CharT> const& a, chset<CharT> const& b)
 60{
 61    return chset<CharT>(a) ^= b;
 62}
 63
 64///////////////////////////////////////////////////////////////////////////////
 65//
 66//  range <--> chset free operators implementation
 67//
 68///////////////////////////////////////////////////////////////////////////////
 69template <typename CharT>
 70inline chset<CharT>
 71operator|(chset<CharT> const& a, range<CharT> const& b)
 72{
 73    chset<CharT> a_(a);
 74    a_.set(b);
 75    return a_;
 76}
 77
 78//////////////////////////////////
 79template <typename CharT>
 80inline chset<CharT>
 81operator&(chset<CharT> const& a, range<CharT> const& b)
 82{
 83    chset<CharT> a_(a);
 84    if(b.first != (std::numeric_limits<CharT>::min)()) {
 85        a_.clear(range<CharT>((std::numeric_limits<CharT>::min)(), b.first - 1));
 86    }
 87    if(b.last != (std::numeric_limits<CharT>::max)()) {
 88        a_.clear(range<CharT>(b.last + 1, (std::numeric_limits<CharT>::max)()));
 89    }
 90    return a_;
 91}
 92
 93//////////////////////////////////
 94template <typename CharT>
 95inline chset<CharT>
 96operator-(chset<CharT> const& a, range<CharT> const& b)
 97{
 98    chset<CharT> a_(a);
 99    a_.clear(b);
100    return a_;
101}
102
103//////////////////////////////////
104template <typename CharT>
105inline chset<CharT>
106operator^(chset<CharT> const& a, range<CharT> const& b)
107{
108    return a ^ chset<CharT>(b);
109}
110
111//////////////////////////////////
112template <typename CharT>
113inline chset<CharT>
114operator|(range<CharT> const& a, chset<CharT> const& b)
115{
116    chset<CharT> b_(b);
117    b_.set(a);
118    return b_;
119}
120
121//////////////////////////////////
122template <typename CharT>
123inline chset<CharT>
124operator&(range<CharT> const& a, chset<CharT> const& b)
125{
126    chset<CharT> b_(b);
127    if(a.first != (std::numeric_limits<CharT>::min)()) {
128        b_.clear(range<CharT>((std::numeric_limits<CharT>::min)(), a.first - 1));
129    }
130    if(a.last != (std::numeric_limits<CharT>::max)()) {
131        b_.clear(range<CharT>(a.last + 1, (std::numeric_limits<CharT>::max)()));
132    }
133    return b_;
134}
135
136//////////////////////////////////
137template <typename CharT>
138inline chset<CharT>
139operator-(range<CharT> const& a, chset<CharT> const& b)
140{
141    return chset<CharT>(a) - b;
142}
143
144//////////////////////////////////
145template <typename CharT>
146inline chset<CharT>
147operator^(range<CharT> const& a, chset<CharT> const& b)
148{
149    return chset<CharT>(a) ^ b;
150}
151
152///////////////////////////////////////////////////////////////////////////////
153//
154//  literal primitives <--> chset free operators implementation
155//
156///////////////////////////////////////////////////////////////////////////////
157template <typename CharT>
158inline chset<CharT>
159operator|(chset<CharT> const& a, CharT b)
160{
161    return a | chset<CharT>(b);
162}
163
164//////////////////////////////////
165template <typename CharT>
166inline chset<CharT>
167operator&(chset<CharT> const& a, CharT b)
168{
169    return a & chset<CharT>(b);
170}
171
172//////////////////////////////////
173template <typename CharT>
174inline chset<CharT>
175operator-(chset<CharT> const& a, CharT b)
176{
177    return a - chset<CharT>(b);
178}
179
180//////////////////////////////////
181template <typename CharT>
182inline chset<CharT>
183operator^(chset<CharT> const& a, CharT b)
184{
185    return a ^ chset<CharT>(b);
186}
187
188//////////////////////////////////
189template <typename CharT>
190inline chset<CharT>
191operator|(CharT a, chset<CharT> const& b)
192{
193    return chset<CharT>(a) | b;
194}
195
196//////////////////////////////////
197template <typename CharT>
198inline chset<CharT>
199operator&(CharT a, chset<CharT> const& b)
200{
201    return chset<CharT>(a) & b;
202}
203
204//////////////////////////////////
205template <typename CharT>
206inline chset<CharT>
207operator-(CharT a, chset<CharT> const& b)
208{
209    return chset<CharT>(a) - b;
210}
211
212//////////////////////////////////
213template <typename CharT>
214inline chset<CharT>
215operator^(CharT a, chset<CharT> const& b)
216{
217    return chset<CharT>(a) ^ b;
218}
219
220///////////////////////////////////////////////////////////////////////////////
221//
222//  chlit <--> chset free operators implementation
223//
224///////////////////////////////////////////////////////////////////////////////
225template <typename CharT>
226inline chset<CharT>
227operator|(chset<CharT> const& a, chlit<CharT> const& b)
228{
229    return a | chset<CharT>(b.ch);
230}
231
232//////////////////////////////////
233template <typename CharT>
234inline chset<CharT>
235operator&(chset<CharT> const& a, chlit<CharT> const& b)
236{
237    return a & chset<CharT>(b.ch);
238}
239
240//////////////////////////////////
241template <typename CharT>
242inline chset<CharT>
243operator-(chset<CharT> const& a, chlit<CharT> const& b)
244{
245    return a - chset<CharT>(b.ch);
246}
247
248//////////////////////////////////
249template <typename CharT>
250inline chset<CharT>
251operator^(chset<CharT> const& a, chlit<CharT> const& b)
252{
253    return a ^ chset<CharT>(b.ch);
254}
255
256//////////////////////////////////
257template <typename CharT>
258inline chset<CharT>
259operator|(chlit<CharT> const& a, chset<CharT> const& b)
260{
261    return chset<CharT>(a.ch) | b;
262}
263
264//////////////////////////////////
265template <typename CharT>
266inline chset<CharT>
267operator&(chlit<CharT> const& a, chset<CharT> const& b)
268{
269    return chset<CharT>(a.ch) & b;
270}
271
272//////////////////////////////////
273template <typename CharT>
274inline chset<CharT>
275operator-(chlit<CharT> const& a, chset<CharT> const& b)
276{
277    return chset<CharT>(a.ch) - b;
278}
279
280//////////////////////////////////
281template <typename CharT>
282inline chset<CharT>
283operator^(chlit<CharT> const& a, chset<CharT> const& b)
284{
285    return chset<CharT>(a.ch) ^ b;
286}
287
288#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
289
290///////////////////////////////////////////////////////////////////////////////
291//
292//  negated_char_parser <--> chset free operators implementation
293//
294///////////////////////////////////////////////////////////////////////////////
295template <typename CharT, typename ParserT>
296inline chset<CharT>
297operator|(chset<CharT> const& a, negated_char_parser<ParserT> const& b)
298{
299    return a | chset<CharT>(b);
300}
301
302//////////////////////////////////
303template <typename CharT, typename ParserT>
304inline chset<CharT>
305operator&(chset<CharT> const& a, negated_char_parser<ParserT> const& b)
306{
307    return a & chset<CharT>(b);
308}
309
310//////////////////////////////////
311template <typename CharT, typename ParserT>
312inline chset<CharT>
313operator-(chset<CharT> const& a, negated_char_parser<ParserT> const& b)
314{
315    return a - chset<CharT>(b);
316}
317
318//////////////////////////////////
319template <typename CharT, typename ParserT>
320inline chset<CharT>
321operator^(chset<CharT> const& a, negated_char_parser<ParserT> const& b)
322{
323    return a ^ chset<CharT>(b);
324}
325
326//////////////////////////////////
327template <typename CharT, typename ParserT>
328inline chset<CharT>
329operator|(negated_char_parser<ParserT> const& a, chset<CharT> const& b)
330{
331    return chset<CharT>(a) | b;
332}
333
334//////////////////////////////////
335template <typename CharT, typename ParserT>
336inline chset<CharT>
337operator&(negated_char_parser<ParserT> const& a, chset<CharT> const& b)
338{
339    return chset<CharT>(a) & b;
340}
341
342//////////////////////////////////
343template <typename CharT, typename ParserT>
344inline chset<CharT>
345operator-(negated_char_parser<ParserT> const& a, chset<CharT> const& b)
346{
347    return chset<CharT>(a) - b;
348}
349
350//////////////////////////////////
351template <typename CharT, typename ParserT>
352inline chset<CharT>
353operator^(negated_char_parser<ParserT> const& a, chset<CharT> const& b)
354{
355    return chset<CharT>(a) ^ b;
356}
357
358#else // BOOST_WORKAROUND(BOOST_MSVC, < 1300)
359
360///////////////////////////////////////////////////////////////////////////////
361//
362//  negated_char_parser<range> <--> chset free operators implementation
363//
364///////////////////////////////////////////////////////////////////////////////
365template <typename CharT>
366inline chset<CharT>
367operator|(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
368{
369    return a | chset<CharT>(b);
370}
371
372//////////////////////////////////
373template <typename CharT>
374inline chset<CharT>
375operator&(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
376{
377    return a & chset<CharT>(b);
378}
379
380//////////////////////////////////
381template <typename CharT>
382inline chset<CharT>
383operator-(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
384{
385    return a - chset<CharT>(b);
386}
387
388//////////////////////////////////
389template <typename CharT>
390inline chset<CharT>
391operator^(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
392{
393    return a ^ chset<CharT>(b);
394}
395
396//////////////////////////////////
397template <typename CharT>
398inline chset<CharT>
399operator|(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
400{
401    return chset<CharT>(a) | b;
402}
403
404//////////////////////////////////
405template <typename CharT>
406inline chset<CharT>
407operator&(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
408{
409    return chset<CharT>(a) & b;
410}
411
412//////////////////////////////////
413template <typename CharT>
414inline chset<CharT>
415operator-(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
416{
417    return chset<CharT>(a) - b;
418}
419
420//////////////////////////////////
421template <typename CharT>
422inline chset<CharT>
423operator^(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
424{
425    return chset<CharT>(a) ^ b;
426}
427
428///////////////////////////////////////////////////////////////////////////////
429//
430//  negated_char_parser<chlit> <--> chset free operators implementation
431//
432///////////////////////////////////////////////////////////////////////////////
433template <typename CharT>
434inline chset<CharT>
435operator|(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
436{
437    return a | chset<CharT>(b);
438}
439
440//////////////////////////////////
441template <typename CharT>
442inline chset<CharT>
443operator&(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
444{
445    return a & chset<CharT>(b);
446}
447
448//////////////////////////////////
449template <typename CharT>
450inline chset<CharT>
451operator-(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
452{
453    return a - chset<CharT>(b);
454}
455
456//////////////////////////////////
457template <typename CharT>
458inline chset<CharT>
459operator^(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
460{
461    return a ^ chset<CharT>(b);
462}
463
464//////////////////////////////////
465template <typename CharT>
466inline chset<CharT>
467operator|(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
468{
469    return chset<CharT>(a) | b;
470}
471
472//////////////////////////////////
473template <typename CharT>
474inline chset<CharT>
475operator&(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
476{
477    return chset<CharT>(a) & b;
478}
479
480//////////////////////////////////
481template <typename CharT>
482inline chset<CharT>
483operator-(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
484{
485    return chset<CharT>(a) - b;
486}
487
488//////////////////////////////////
489template <typename CharT>
490inline chset<CharT>
491operator^(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
492{
493    return chset<CharT>(a) ^ b;
494}
495
496#endif // BOOST_WORKAROUND(BOOST_MSVC, < 1300)
497
498///////////////////////////////////////////////////////////////////////////////
499//
500//  anychar_parser <--> chset free operators
501//
502//      Where a is chset and b is a anychar_parser, and vice-versa, implements:
503//
504//          a | b, a & b, a - b, a ^ b
505//
506///////////////////////////////////////////////////////////////////////////////
507namespace impl {
508
509    template <typename CharT>
510    inline BOOST_SPIRIT_CLASSIC_NS::range<CharT> const&
511    full()
512    {
513        static BOOST_SPIRIT_CLASSIC_NS::range<CharT> full_(
514            (std::numeric_limits<CharT>::min)(),
515            (std::numeric_limits<CharT>::max)());
516        return full_;
517    }
518
519    template <typename CharT>
520    inline BOOST_SPIRIT_CLASSIC_NS::range<CharT> const&
521    empty()
522    {
523        static BOOST_SPIRIT_CLASSIC_NS::range<CharT> empty_;
524        return empty_;
525    }
526}
527
528//////////////////////////////////
529template <typename CharT>
530inline chset<CharT>
531operator|(chset<CharT> const&, anychar_parser)
532{
533    return chset<CharT>(impl::full<CharT>());
534}
535
536//////////////////////////////////
537template <typename CharT>
538inline chset<CharT>
539operator&(chset<CharT> const& a, anychar_parser)
540{
541    return a;
542}
543
544//////////////////////////////////
545template <typename CharT>
546inline chset<CharT>
547operator-(chset<CharT> const&, anychar_parser)
548{
549    return chset<CharT>();
550}
551
552//////////////////////////////////
553template <typename CharT>
554inline chset<CharT>
555operator^(chset<CharT> const& a, anychar_parser)
556{
557    return ~a;
558}
559
560//////////////////////////////////
561template <typename CharT>
562inline chset<CharT>
563operator|(anychar_parser, chset<CharT> const& /*b*/)
564{
565    return chset<CharT>(impl::full<CharT>());
566}
567
568//////////////////////////////////
569template <typename CharT>
570inline chset<CharT>
571operator&(anychar_parser, chset<CharT> const& b)
572{
573    return b;
574}
575
576//////////////////////////////////
577template <typename CharT>
578inline chset<CharT>
579operator-(anychar_parser, chset<CharT> const& b)
580{
581    return ~b;
582}
583
584//////////////////////////////////
585template <typename CharT>
586inline chset<CharT>
587operator^(anychar_parser, chset<CharT> const& b)
588{
589    return ~b;
590}
591
592///////////////////////////////////////////////////////////////////////////////
593//
594//  nothing_parser <--> chset free operators implementation
595//
596///////////////////////////////////////////////////////////////////////////////
597template <typename CharT>
598inline chset<CharT>
599operator|(chset<CharT> const& a, nothing_parser)
600{
601    return a;
602}
603
604//////////////////////////////////
605template <typename CharT>
606inline chset<CharT>
607operator&(chset<CharT> const& /*a*/, nothing_parser)
608{
609    return impl::empty<CharT>();
610}
611
612//////////////////////////////////
613template <typename CharT>
614inline chset<CharT>
615operator-(chset<CharT> const& a, nothing_parser)
616{
617    return a;
618}
619
620//////////////////////////////////
621template <typename CharT>
622inline chset<CharT>
623operator^(chset<CharT> const& a, nothing_parser)
624{
625    return a;
626}
627
628//////////////////////////////////
629template <typename CharT>
630inline chset<CharT>
631operator|(nothing_parser, chset<CharT> const& b)
632{
633    return b;
634}
635
636//////////////////////////////////
637template <typename CharT>
638inline chset<CharT>
639operator&(nothing_parser, chset<CharT> const& /*b*/)
640{
641    return impl::empty<CharT>();
642}
643
644//////////////////////////////////
645template <typename CharT>
646inline chset<CharT>
647operator-(nothing_parser, chset<CharT> const& /*b*/)
648{
649    return impl::empty<CharT>();
650}
651
652//////////////////////////////////
653template <typename CharT>
654inline chset<CharT>
655operator^(nothing_parser, chset<CharT> const& b)
656{
657    return b;
658}
659
660///////////////////////////////////////////////////////////////////////////////
661BOOST_SPIRIT_CLASSIC_NAMESPACE_END
662
663}} // namespace boost::spirit
664
665#endif
666