_M_extract_name()

template<typename _CharT, typename _InIter>

_InIter std::time_get< _CharT, _InIter >::_M_extract_name ( iter_type __beg, iter_type __end, int & __member, const _CharT ** __names, size_t __indexlen, ios_base & __io, ios_base::iostate & __err ) const

protectedinherited

Definition at line 1093 of file locale_facets_nonio.tcc.

    {
      typedef char_traits<_CharT>         __traits_type;
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
 
      size_t* __matches
      = static_cast<size_t*>(__builtin_alloca(2 * sizeof(size_t)
                                    * __indexlen));
      size_t* __lengths = __matches + __indexlen;
      size_t __nmatches = 0;
      size_t __pos = 0;
      bool __testvalid = true;
      const char_type* __name;
      bool __begupdated = false;
 
      // Look for initial matches.
      if (__beg != __end)
      {
        const char_type __c = *__beg;
        // TODO real case-insensitive comparison
        const char_type __cl = __ctype.tolower(__c);
        const char_type __cu = __ctype.toupper(__c);
        for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
          if (__cl == __ctype.tolower(__names[__i1][0])
            || __cu == __ctype.toupper(__names[__i1][0]))
            {
            __lengths[__nmatches]
              = __traits_type::length(__names[__i1]);
            __matches[__nmatches++] = __i1;
            }
      }
 
      while (__nmatches > 1)
      {
        // Find smallest matching string.
        size_t __minlen = __lengths[0];
        for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
          __minlen = std::min(__minlen, __lengths[__i2]);
        ++__pos;
        ++__beg;
        if (__pos == __minlen)
          {
            // If some match has remaining length of 0,
            // need to decide if any match with remaining
            // length non-zero matches the next character.
            // If so, remove all matches with remaining length
            // 0 from consideration, otherwise keep only matches
            // with remaining length 0.
            bool __match_longer = false;
 
            if (__beg != __end)
            {
              // TODO real case-insensitive comparison
              const char_type __cl = __ctype.tolower(*__beg);
              const char_type __cu = __ctype.toupper(*__beg);
              for (size_t __i3 = 0; __i3 < __nmatches; ++__i3)
                {
                  __name = __names[__matches[__i3]];
                  if (__lengths[__i3] > __pos
                    && (__ctype.tolower(__name[__pos]) == __cl
                        || __ctype.toupper(__name[__pos]) == __cu))
                  {
                    __match_longer = true;
                    break;
                  }
                }
            }
            for (size_t __i4 = 0; __i4 < __nmatches;)
            if (__match_longer == (__lengths[__i4] == __pos))
              {
                __matches[__i4] = __matches[--__nmatches];
                __lengths[__i4] = __lengths[__nmatches];
              }
            else
              ++__i4;
            if (__match_longer)
            {
              __minlen = __lengths[0];
              for (size_t __i5 = 1; __i5 < __nmatches; ++__i5)
                __minlen = std::min(__minlen, __lengths[__i5]);
            }
            else
            {
              // Deal with May being full as well as abbreviated month
              // name.  Pick the smaller index.
              if (__nmatches == 2 && (__indexlen & 1) == 0)
                {
                  if (__matches[0] < __indexlen / 2)
                  {
                    if (__matches[1] == __matches[0] + __indexlen / 2)
                      __nmatches = 1;
                  }
                  else if (__matches[1] == __matches[0] - __indexlen / 2)
                  {
                    __matches[0] = __matches[1];
                    __lengths[0] = __lengths[1];
                    __nmatches = 1;
                  }
                }
              __begupdated = true;
              break;
            }
          }
        if (__pos < __minlen && __beg != __end)
          {
            // TODO real case-insensitive comparison
            const char_type __cl = __ctype.tolower(*__beg);
            const char_type __cu = __ctype.toupper(*__beg);
            for (size_t __i6 = 0; __i6 < __nmatches;)
            {
              __name = __names[__matches[__i6]];
              if (__ctype.tolower(__name[__pos]) != __cl
                  && __ctype.toupper(__name[__pos]) != __cu)
                {
                  __matches[__i6] = __matches[--__nmatches];
                  __lengths[__i6] = __lengths[__nmatches];
                }
              else
                ++__i6;
            }
          }
        else
          break;
      }
 
      if (__nmatches == 1)
      {
        // Make sure found name is completely extracted.
        if (!__begupdated)
          {
            ++__beg;
            ++__pos;
          }
        __name = __names[__matches[0]];
        const size_t __len = __lengths[0];
        while (__pos < __len
             && __beg != __end
             // TODO real case-insensitive comparison
             && (__ctype.tolower(__name[__pos]) == __ctype.tolower(*__beg)
                 || (__ctype.toupper(__name[__pos])
                   == __ctype.toupper(*__beg))))
          ++__beg, (void)++__pos;
 
        if (__len == __pos)
          __member = __matches[0];
        else
          __testvalid = false;
      }
      else
      __testvalid = false;
      if (!__testvalid)
      __err |= ios_base::failbit;
 
      return __beg;
    }

References time_get(), std::ios_base::_M_getloc(), std::ios_base::failbit, std::locale::facet::locale, std::min(), std::__ctype_abstract_base< _CharT >::tolower(), std::__ctype_abstract_base< _CharT >::toupper(), and std::use_facet().

Referenced by _M_extract_via_format().

Here is the call graph for this function:

Here is the caller graph for this function: