diff options
Diffstat (limited to 'inference-engine/thirdparty/clDNN/common/boost/1.64.0/include/boost-1_64/boost/format/parsing.hpp')
-rw-r--r-- | inference-engine/thirdparty/clDNN/common/boost/1.64.0/include/boost-1_64/boost/format/parsing.hpp | 505 |
1 files changed, 0 insertions, 505 deletions
diff --git a/inference-engine/thirdparty/clDNN/common/boost/1.64.0/include/boost-1_64/boost/format/parsing.hpp b/inference-engine/thirdparty/clDNN/common/boost/1.64.0/include/boost-1_64/boost/format/parsing.hpp deleted file mode 100644 index bfddfef76..000000000 --- a/inference-engine/thirdparty/clDNN/common/boost/1.64.0/include/boost-1_64/boost/format/parsing.hpp +++ /dev/null @@ -1,505 +0,0 @@ -// ---------------------------------------------------------------------------- -// parsing.hpp : implementation of the parsing member functions -// ( parse, parse_printf_directive) -// ---------------------------------------------------------------------------- - -// Copyright Samuel Krempp 2003. Use, modification, and distribution are -// subject to the Boost Software License, Version 1.0. (See accompanying -// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) - -// see http://www.boost.org/libs/format for library home page - -// ---------------------------------------------------------------------------- - -#ifndef BOOST_FORMAT_PARSING_HPP -#define BOOST_FORMAT_PARSING_HPP - - -#include <boost/format/format_class.hpp> -#include <boost/format/exceptions.hpp> -#include <boost/throw_exception.hpp> -#include <boost/assert.hpp> -#include <boost/config.hpp> - - -namespace boost { -namespace io { -namespace detail { - -#if defined(BOOST_NO_STD_LOCALE) - // streams will be used for narrow / widen. but these methods are not const - template<class T> - T& const_or_not(const T& x) { - return const_cast<T&> (x); - } -#else - template<class T> - const T& const_or_not(const T& x) { - return x; - } -#endif - - template<class Ch, class Facet> inline - char wrap_narrow(const Facet& fac, Ch c, char deflt) { - return const_or_not(fac).narrow(c, deflt); - } - - template<class Ch, class Facet> inline - bool wrap_isdigit(const Facet& fac, Ch c) { -#if ! defined( BOOST_NO_LOCALE_ISDIGIT ) - return fac.is(std::ctype<Ch>::digit, c); -# else - (void) fac; // remove "unused parameter" warning - using namespace std; - return isdigit(c) != 0; -#endif - } - - template<class Iter, class Facet> - Iter wrap_scan_notdigit(const Facet & fac, Iter beg, Iter end) { - using namespace std; - for( ; beg!=end && wrap_isdigit(fac, *beg); ++beg) ; - return beg; - } - - - // Input : [start, last) iterators range and a - // a Facet to use its widen/narrow member function - // Effects : read sequence and convert digits into integral n, of type Res - // Returns : n - template<class Res, class Iter, class Facet> - Iter str2int (const Iter & start, const Iter & last, Res & res, - const Facet& fac) - { - using namespace std; - Iter it; - res=0; - for(it=start; it != last && wrap_isdigit(fac, *it); ++it ) { - char cur_ch = wrap_narrow(fac, *it, 0); // cant fail. - res *= 10; - res += cur_ch - '0'; // 22.2.1.1.2.13 of the C++ standard - } - return it; - } - - // skip printf's "asterisk-fields" directives in the format-string buf - // Input : char string, with starting index *pos_p - // a Facet merely to use its widen/narrow member function - // Effects : advance *pos_p by skipping printf's asterisk fields. - // Returns : nothing - template<class Iter, class Facet> - Iter skip_asterisk(Iter start, Iter last, const Facet& fac) - { - using namespace std; - ++ start; - start = wrap_scan_notdigit(fac, start, last); - if(start!=last && *start== const_or_not(fac).widen( '$') ) - ++start; - return start; - } - - - // auxiliary func called by parse_printf_directive - // for centralising error handling - // it either throws if user sets the corresponding flag, or does nothing. - inline void maybe_throw_exception(unsigned char exceptions, - std::size_t pos, std::size_t size) - { - if(exceptions & io::bad_format_string_bit) - boost::throw_exception(io::bad_format_string(pos, size) ); - } - - - // Input: the position of a printf-directive in the format-string - // a basic_ios& merely to use its widen/narrow member function - // a bitset'exceptions' telling whether to throw exceptions on errors. - // Returns: - // true if parse succeeded (ignore some errors if exceptions disabled) - // false if it failed so bad that the directive should be printed verbatim - // Effects: - // start is incremented so that *start is the first char after - // this directive - // *fpar is set with the parameters read in the directive - template<class Ch, class Tr, class Alloc, class Iter, class Facet> - bool parse_printf_directive(Iter & start, const Iter& last, - detail::format_item<Ch, Tr, Alloc> * fpar, - const Facet& fac, - std::size_t offset, unsigned char exceptions) - { - typedef typename basic_format<Ch, Tr, Alloc>::format_item_t format_item_t; - - fpar->argN_ = format_item_t::argN_no_posit; // if no positional-directive - bool precision_set = false; - bool in_brackets=false; - Iter start0 = start; - std::size_t fstring_size = last-start0+offset; - - if(start>= last) { // empty directive : this is a trailing % - maybe_throw_exception(exceptions, start-start0 + offset, fstring_size); - return false; - } - - if(*start== const_or_not(fac).widen( '|')) { - in_brackets=true; - if( ++start >= last ) { - maybe_throw_exception(exceptions, start-start0 + offset, fstring_size); - return false; - } - } - - // the flag '0' would be picked as a digit for argument order, but here it's a flag : - if(*start== const_or_not(fac).widen( '0')) - goto parse_flags; - - // handle argument order (%2$d) or possibly width specification: %2d - if(wrap_isdigit(fac, *start)) { - int n; - start = str2int(start, last, n, fac); - if( start >= last ) { - maybe_throw_exception(exceptions, start-start0+offset, fstring_size); - return false; - } - - // %N% case : this is already the end of the directive - if( *start == const_or_not(fac).widen( '%') ) { - fpar->argN_ = n-1; - ++start; - if( in_brackets) - maybe_throw_exception(exceptions, start-start0+offset, fstring_size); - // but don't return. maybe "%" was used in lieu of '$', so we go on. - else - return true; - } - - if ( *start== const_or_not(fac).widen( '$') ) { - fpar->argN_ = n-1; - ++start; - } - else { - // non-positionnal directive - fpar->fmtstate_.width_ = n; - fpar->argN_ = format_item_t::argN_no_posit; - goto parse_precision; - } - } - - parse_flags: - // handle flags - while ( start != last) { // as long as char is one of + - = _ # 0 l h or ' ' - // misc switches - switch ( wrap_narrow(fac, *start, 0)) { - case '\'' : break; // no effect yet. (painful to implement) - case 'l': - case 'h': // short/long modifier : for printf-comaptibility (no action needed) - break; - case '-': - fpar->fmtstate_.flags_ |= std::ios_base::left; - break; - case '=': - fpar->pad_scheme_ |= format_item_t::centered; - break; - case '_': - fpar->fmtstate_.flags_ |= std::ios_base::internal; - break; - case ' ': - fpar->pad_scheme_ |= format_item_t::spacepad; - break; - case '+': - fpar->fmtstate_.flags_ |= std::ios_base::showpos; - break; - case '0': - fpar->pad_scheme_ |= format_item_t::zeropad; - // need to know alignment before really setting flags, - // so just add 'zeropad' flag for now, it will be processed later. - break; - case '#': - fpar->fmtstate_.flags_ |= std::ios_base::showpoint | std::ios_base::showbase; - break; - default: - goto parse_width; - } - ++start; - } // loop on flag. - - if( start>=last) { - maybe_throw_exception(exceptions, start-start0+offset, fstring_size); - return true; - } - parse_width: - // handle width spec - // first skip 'asterisk fields' : *, or *N$ - if(*start == const_or_not(fac).widen( '*') ) - start = skip_asterisk(start, last, fac); - if(start!=last && wrap_isdigit(fac, *start)) - start = str2int(start, last, fpar->fmtstate_.width_, fac); - - parse_precision: - if( start>= last) { - maybe_throw_exception(exceptions, start-start0+offset, fstring_size); - return true; - } - // handle precision spec - if (*start== const_or_not(fac).widen( '.')) { - ++start; - if(start != last && *start == const_or_not(fac).widen( '*') ) - start = skip_asterisk(start, last, fac); - if(start != last && wrap_isdigit(fac, *start)) { - start = str2int(start, last, fpar->fmtstate_.precision_, fac); - precision_set = true; - } - else - fpar->fmtstate_.precision_ =0; - } - - // handle formatting-type flags : - while( start != last && ( *start== const_or_not(fac).widen( 'l') - || *start== const_or_not(fac).widen( 'L') - || *start== const_or_not(fac).widen( 'h')) ) - ++start; - if( start>=last) { - maybe_throw_exception(exceptions, start-start0+offset, fstring_size); - return true; - } - - if( in_brackets && *start== const_or_not(fac).widen( '|') ) { - ++start; - return true; - } - switch ( wrap_narrow(fac, *start, 0) ) { - case 'X': - fpar->fmtstate_.flags_ |= std::ios_base::uppercase; - BOOST_FALLTHROUGH; - case 'p': // pointer => set hex. - case 'x': - fpar->fmtstate_.flags_ &= ~std::ios_base::basefield; - fpar->fmtstate_.flags_ |= std::ios_base::hex; - break; - - case 'o': - fpar->fmtstate_.flags_ &= ~std::ios_base::basefield; - fpar->fmtstate_.flags_ |= std::ios_base::oct; - break; - - case 'E': - fpar->fmtstate_.flags_ |= std::ios_base::uppercase; - BOOST_FALLTHROUGH; - case 'e': - fpar->fmtstate_.flags_ &= ~std::ios_base::floatfield; - fpar->fmtstate_.flags_ |= std::ios_base::scientific; - - fpar->fmtstate_.flags_ &= ~std::ios_base::basefield; - fpar->fmtstate_.flags_ |= std::ios_base::dec; - break; - - case 'f': - fpar->fmtstate_.flags_ &= ~std::ios_base::floatfield; - fpar->fmtstate_.flags_ |= std::ios_base::fixed; - BOOST_FALLTHROUGH; - case 'u': - case 'd': - case 'i': - fpar->fmtstate_.flags_ &= ~std::ios_base::basefield; - fpar->fmtstate_.flags_ |= std::ios_base::dec; - break; - - case 'T': - ++start; - if( start >= last) - maybe_throw_exception(exceptions, start-start0+offset, fstring_size); - else - fpar->fmtstate_.fill_ = *start; - fpar->pad_scheme_ |= format_item_t::tabulation; - fpar->argN_ = format_item_t::argN_tabulation; - break; - case 't': - fpar->fmtstate_.fill_ = const_or_not(fac).widen( ' '); - fpar->pad_scheme_ |= format_item_t::tabulation; - fpar->argN_ = format_item_t::argN_tabulation; - break; - - case 'G': - fpar->fmtstate_.flags_ |= std::ios_base::uppercase; - break; - case 'g': // 'g' conversion is default for floats. - fpar->fmtstate_.flags_ &= ~std::ios_base::basefield; - fpar->fmtstate_.flags_ |= std::ios_base::dec; - - // CLEAR all floatield flags, so stream will CHOOSE - fpar->fmtstate_.flags_ &= ~std::ios_base::floatfield; - break; - - case 'C': - case 'c': - fpar->truncate_ = 1; - break; - case 'S': - case 's': - if(precision_set) // handle truncation manually, with own parameter. - fpar->truncate_ = fpar->fmtstate_.precision_; - fpar->fmtstate_.precision_ = 6; // default stream precision. - break; - case 'n' : - fpar->argN_ = format_item_t::argN_ignored; - break; - default: - maybe_throw_exception(exceptions, start-start0+offset, fstring_size); - } - ++start; - - if( in_brackets ) { - if( start != last && *start== const_or_not(fac).widen( '|') ) { - ++start; - return true; - } - else maybe_throw_exception(exceptions, start-start0+offset, fstring_size); - } - return true; - } - // -end parse_printf_directive() - - template<class String, class Facet> - int upper_bound_from_fstring(const String& buf, - const typename String::value_type arg_mark, - const Facet& fac, - unsigned char exceptions) - { - // quick-parsing of the format-string to count arguments mark (arg_mark, '%') - // returns : upper bound on the number of format items in the format strings - using namespace boost::io; - typename String::size_type i1=0; - int num_items=0; - while( (i1=buf.find(arg_mark,i1)) != String::npos ) { - if( i1+1 >= buf.size() ) { - if(exceptions & bad_format_string_bit) - boost::throw_exception(bad_format_string(i1, buf.size() )); // must not end in ".. %" - else { - ++num_items; - break; - } - } - if(buf[i1+1] == buf[i1] ) {// escaped "%%" - i1+=2; continue; - } - - ++i1; - // in case of %N% directives, dont count it double (wastes allocations..) : - i1 = detail::wrap_scan_notdigit(fac, buf.begin()+i1, buf.end()) - buf.begin(); - if( i1 < buf.size() && buf[i1] == arg_mark ) - ++i1; - ++num_items; - } - return num_items; - } - template<class String> inline - void append_string(String& dst, const String& src, - const typename String::size_type beg, - const typename String::size_type end) { - dst.append(src.begin()+beg, src.begin()+end); - } - -} // detail namespace -} // io namespace - - - -// ----------------------------------------------- -// format :: parse(..) - - template<class Ch, class Tr, class Alloc> - basic_format<Ch, Tr, Alloc>& basic_format<Ch, Tr, Alloc>:: - parse (const string_type& buf) { - // parse the format-string - using namespace std; -#if !defined(BOOST_NO_STD_LOCALE) - const std::ctype<Ch> & fac = BOOST_USE_FACET( std::ctype<Ch>, getloc()); -#else - io::basic_oaltstringstream<Ch, Tr, Alloc> fac; - //has widen and narrow even on compilers without locale -#endif - - const Ch arg_mark = io::detail::const_or_not(fac).widen( '%'); - bool ordered_args=true; - int max_argN=-1; - - // A: find upper_bound on num_items and allocates arrays - int num_items = io::detail::upper_bound_from_fstring(buf, arg_mark, fac, exceptions()); - make_or_reuse_data(num_items); - - // B: Now the real parsing of the format string : - num_items=0; - typename string_type::size_type i0=0, i1=0; - typename string_type::const_iterator it; - bool special_things=false; - int cur_item=0; - while( (i1=buf.find(arg_mark,i1)) != string_type::npos ) { - string_type & piece = (cur_item==0) ? prefix_ : items_[cur_item-1].appendix_; - if( buf[i1+1] == buf[i1] ) { // escaped mark, '%%' - io::detail::append_string(piece, buf, i0, i1+1); - i1+=2; i0=i1; - continue; - } - BOOST_ASSERT( static_cast<unsigned int>(cur_item) < items_.size() || cur_item==0); - - if(i1!=i0) { - io::detail::append_string(piece, buf, i0, i1); - i0=i1; - } - ++i1; - it = buf.begin()+i1; - bool parse_ok = io::detail::parse_printf_directive( - it, buf.end(), &items_[cur_item], fac, i1, exceptions()); - i1 = it - buf.begin(); - if( ! parse_ok ) // the directive will be printed verbatim - continue; - i0=i1; - items_[cur_item].compute_states(); // process complex options, like zeropad, into params - - int argN=items_[cur_item].argN_; - if(argN == format_item_t::argN_ignored) - continue; - if(argN ==format_item_t::argN_no_posit) - ordered_args=false; - else if(argN == format_item_t::argN_tabulation) special_things=true; - else if(argN > max_argN) max_argN = argN; - ++num_items; - ++cur_item; - } // loop on %'s - BOOST_ASSERT(cur_item == num_items); - - // store the final piece of string - { - string_type & piece = (cur_item==0) ? prefix_ : items_[cur_item-1].appendix_; - io::detail::append_string(piece, buf, i0, buf.size()); - } - - if( !ordered_args) { - if(max_argN >= 0 ) { // dont mix positional with non-positionnal directives - if(exceptions() & io::bad_format_string_bit) - boost::throw_exception( - io::bad_format_string(static_cast<std::size_t>(max_argN), 0)); - // else do nothing. => positionnal arguments are processed as non-positionnal - } - // set things like it would have been with positional directives : - int non_ordered_items = 0; - for(int i=0; i< num_items; ++i) - if(items_[i].argN_ == format_item_t::argN_no_posit) { - items_[i].argN_ = non_ordered_items; - ++non_ordered_items; - } - max_argN = non_ordered_items-1; - } - - // C: set some member data : - items_.resize(num_items, format_item_t(io::detail::const_or_not(fac).widen( ' ')) ); - - if(special_things) style_ |= special_needs; - num_args_ = max_argN + 1; - if(ordered_args) style_ |= ordered; - else style_ &= ~ordered; - return *this; - } - -} // namespace boost - - -#endif // BOOST_FORMAT_PARSING_HPP |