reactos/sdk/include/c++/stlport/stl/_time_facets.c

   1 /*
   2  * Copyright (c) 1999
   3  * Silicon Graphics Computer Systems, Inc.
   4  *
   5  * Copyright (c) 1999
   6  * Boris Fomitchev
   7  *
   8  * This material is provided "as is", with absolutely no warranty expressed
   9  * or implied. Any use is at your own risk.
  10  *
  11  * Permission to use or copy this software for any purpose is hereby granted
  12  * without fee, provided the above notices are retained on all copies.
  13  * Permission to modify the code and to distribute modified code is granted,
  14  * provided the above notices are retained, and a notice that the code was
  15  * modified is included with the above copyright notice.
  16  *
  17  */
  18 #ifndef _STLP_TIME_FACETS_C
  19 #define _STLP_TIME_FACETS_C
  20
  21 #ifndef _STLP_INTERNAL_TIME_FACETS_H
  22 #  include <stl/_time_facets.h>
  23 #endif
  24
  25 #ifndef _STLP_INTERNAL_NUM_PUT_H
  26 #  include <stl/_num_put.h>
  27 #endif
  28
  29 #ifndef _STLP_INTERNAL_NUM_GET_H
  30 #  include <stl/_num_get.h>
  31 #endif
  32
  33 _STLP_BEGIN_NAMESPACE
  34
  35 //----------------------------------------------------------------------
  36 // Declarations of static template members.
  37
  38 template <class _CharT, class _InputIterator>
  39 locale::id time_get<_CharT, _InputIterator>::id;
  40
  41 template <class _CharT, class _OutputIterator>
  42 locale::id time_put<_CharT, _OutputIterator>::id;
  43
  44 _STLP_MOVE_TO_PRIV_NAMESPACE
  45
  46 /* Matching input against a list of names
  47
  48  * Alphabetic input of the names of months and the names
  49  * of weekdays requires matching input against a list of names.
  50  * We use a simple generic algorithm to accomplish this.  This
  51  * algorithm is not very efficient, especially for longer lists
  52  * of names, but it probably does not matter for the initial
  53  * implementation and it may never matter, since we do not expect
  54  * this kind of input to be used very often.  The algorithm
  55  * could be improved fairly simply by creating a new list of
  56  * names still in the running at each iteration.  A more sophisticated
  57  * approach would be to build a tree to do the matching.
  58  *
  59  * We compare each character of the input to the corresponding
  60  * character of each name on the list that has not been eliminated,
  61  * either because every character in the name has already been
  62  * matched, or because some character has not been matched.  We
  63  * continue only as long as there are some names that have not been
  64  * eliminated.
  65
  66  * We do not really need a random access iterator (a forward iterator
  67  * would do), but the extra generality makes the notation clumsier,
  68  * and we don't really need it.
  69
  70  * We can recognize a failed match by the fact that the return value
  71  * will be __name_end.
  72  */
  73
  74 #define _MAXNAMES        24
  75
  76 template <class _InIt, class _NameIt>
  77 size_t _STLP_CALL
  78 __match(_InIt& __first, _InIt& __last, _NameIt __name, _NameIt __name_end) {
  79   typedef ptrdiff_t difference_type;
  80   difference_type __n = __name_end - __name;
  81   difference_type __i, __start = 0;
  82   size_t __pos = 0;
  83   difference_type __check_count = __n;
  84   bool __do_not_check[_MAXNAMES];
  85   size_t __matching_name_index = __n;
  86
  87   memset(__do_not_check, 0, sizeof(__do_not_check));
  88
  89   while (__first != __last) {
  90     difference_type __new_n = __n;
  91     for (__i = __start; __i < __n; ++__i) {
  92       if (!__do_not_check[__i]) {
  93         if (*__first == __name[__i][__pos]) {
  94           if (__pos == (__name[__i].size() - 1)) {
  95             __matching_name_index = __i;
  96             __do_not_check[__i] = true;
  97             if (__i == __start) ++__start;
  98             --__check_count;
  99             if (__check_count == 0) {
 100               ++__first;
 101               return __matching_name_index;
 102             }
 103           }
 104           __new_n = __i + 1;
 105         }
 106         else {
 107           __do_not_check[__i] = true;
 108           if (__i == __start) ++__start;
 109           --__check_count;
 110           if (__check_count == 0)
 111             return __matching_name_index;
 112         }
 113       }
 114       else {
 115         if (__i == __start) ++ __start;
 116       }
 117     }
 118
 119     __n = __new_n;
 120     ++__first; ++__pos;
 121   }
 122
 123   return __matching_name_index;
 124 }
 125
 126 // __get_formatted_time reads input that is assumed to be formatted
 127 // according to the rules for the C strftime function (C standard,
 128 // 7.12.3.5).  This function is used to implement the do_get_time
 129 // and do_get_date virtual functions, which depend on the locale
 130 // specifications for the time and day formats respectively.
 131 // Note the catchall default case, intended mainly for the '%Z'
 132 // format designator, which does not make sense here since the
 133 // representation of timezones is not part of the locale.
 134 //
 135 // The case branches are implemented either by doing a match using
 136 // the appopriate name table or by doing a __get_integer_nogroup.
 137 //
 138 // 'y' format is assumed to mean that the input represents years
 139 // since 1900.  That is, 2002 should be represented as 102.  There
 140 // is no century-guessing.
 141 //
 142 // The match is successful if and only if the second component of the
 143 // return value is format_end.
 144
 145 // Note that the antepenultimate parameter is being used only to determine
 146 // the correct overloading for the calls to __get_integer_nogroup.
 147 template <class _InIt1, class _Ch, class _TimeInfo>
 148 string::const_iterator _STLP_CALL
 149 __get_formatted_time _STLP_WEAK (_InIt1 __first,  _InIt1 __last,
 150                                  string::const_iterator __format, string::const_iterator __format_end,
 151                                  _Ch*, const _TimeInfo& __table,
 152                                  const ios_base& __s, ios_base::iostate& __err, tm* __t) {
 153   const ctype<_Ch>& __ct = use_facet<ctype<_Ch> >(__s.getloc());
 154   typedef basic_string<_Ch, char_traits<_Ch>, allocator<_Ch> > string_type;
 155   size_t offset;
 156
 157   while (__first != __last && __format != __format_end) {
 158     offset = 0;
 159     if (*__format == '%') {
 160       ++__format;
 161       char __c = *__format;
 162       if (__c == '#') { //MS extension
 163         ++__format;
 164         __c = *__format;
 165       }
 166
 167       switch (__c) {
 168         case 'A':
 169           offset = 7;
 170         case 'a': {
 171           size_t __index = __match(__first, __last,
 172                                    __table._M_dayname + offset, __table._M_dayname + offset + 7);
 173           if (__index == 7)
 174             return __format;
 175           __t->tm_wday = __STATIC_CAST(int, __index);
 176           break;
 177         }
 178
 179         case 'B':
 180           offset = 12;
 181         case 'b': {
 182           size_t __index = __match(__first, __last,
 183                                    __table._M_monthname + offset, __table._M_monthname + offset + 12);
 184           if (__index == 12)
 185             return __format;
 186           __t->tm_mon = __STATIC_CAST(int, __index);
 187           break;
 188         }
 189
 190         case 'd': {
 191           bool __pr = __get_decimal_integer(__first, __last, __t->tm_mday, __STATIC_CAST(_Ch*, 0));
 192           if (!__pr || __t->tm_mday < 1 || __t->tm_mday > 31) {
 193             __err |= ios_base::failbit;
 194             return __format;
 195           }
 196           break;
 197         }
 198
 199         case 'H': case 'I': {
 200           bool __pr = __get_decimal_integer(__first, __last, __t->tm_hour, __STATIC_CAST(_Ch*, 0));
 201           if (!__pr)
 202             return __format;
 203           break;
 204         }
 205
 206         case 'j': {
 207           bool __pr = __get_decimal_integer(__first, __last, __t->tm_yday, __STATIC_CAST(_Ch*, 0));
 208           if (!__pr)
 209             return __format;
 210           break;
 211         }
 212
 213         case 'm': {
 214           bool __pr = __get_decimal_integer(__first, __last, __t->tm_mon, __STATIC_CAST(_Ch*, 0));
 215           --__t->tm_mon;
 216           if (!__pr || __t->tm_mon < 0 || __t->tm_mon > 11) {
 217             __err |= ios_base::failbit;
 218             return __format;
 219           }
 220           break;
 221         }
 222
 223         case 'M': {
 224           bool __pr = __get_decimal_integer(__first, __last, __t->tm_min, __STATIC_CAST(_Ch*, 0));
 225           if (!__pr)
 226             return __format;
 227           break;
 228         }
 229
 230         case 'p': {
 231           size_t __index = __match(__first, __last,
 232                                    __table._M_am_pm + 0, __table._M_am_pm + 2);
 233           if (__index == 2)
 234             return __format;
 235           // 12:00 PM <=> 12:00, 12:00 AM <=> 00:00
 236           if (__index == 1 && __t->tm_hour != 12 )
 237             __t->tm_hour += 12;
 238           if (__index == 0 && __t->tm_hour == 12 )
 239             __t->tm_hour = 0;
 240           break;
 241         }
 242
 243         case 'S': {
 244           bool __pr = __get_decimal_integer(__first, __last, __t->tm_sec, __STATIC_CAST(_Ch*, 0));
 245           if (!__pr)
 246             return __format;
 247           break;
 248         }
 249
 250         case 'y': {
 251           bool __pr = __get_decimal_integer(__first, __last, __t->tm_year, __STATIC_CAST(_Ch*, 0));
 252           if (!__pr)
 253             return __format;
 254           break;
 255         }
 256
 257         case 'Y': {
 258           bool __pr = __get_decimal_integer(__first, __last, __t->tm_year, __STATIC_CAST(_Ch*, 0));
 259           __t->tm_year -= 1900;
 260           if (!__pr)
 261             return __format;
 262           break;
 263         }
 264
 265         default:
 266           break;
 267       }
 268     }
 269     else {
 270       if (*__first++ != __ct.widen(*__format)) break;
 271     }
 272
 273     ++__format;
 274   }
 275
 276   return __format;
 277 }
 278
 279 template <class _InIt, class _TimeInfo>
 280 bool _STLP_CALL
 281 __get_short_or_long_dayname(_InIt& __first, _InIt& __last, const _TimeInfo& __table, tm* __t) {
 282   size_t __index = __match(__first, __last, __table._M_dayname + 0, __table._M_dayname + 14);
 283   if (__index != 14) {
 284     __t->tm_wday = __STATIC_CAST(int, __index % 7);
 285     return true;
 286   }
 287   return false;
 288 }
 289
 290 template <class _InIt, class _TimeInfo>
 291 bool _STLP_CALL
 292 __get_short_or_long_monthname(_InIt& __first, _InIt& __last, const _TimeInfo& __table, tm* __t) {
 293   size_t __index = __match(__first, __last, __table._M_monthname + 0, __table._M_monthname + 24);
 294   if (__index != 24) {
 295     __t->tm_mon = __STATIC_CAST(int, __index % 12);
 296     return true;
 297   }
 298   return false;
 299 }
 300
 301 _STLP_MOVE_TO_STD_NAMESPACE
 302
 303 template <class _Ch, class _InIt>
 304 _InIt
 305 time_get<_Ch, _InIt>::do_get_date(_InIt __s, _InIt  __end,
 306                                   ios_base& __str, ios_base::iostate&  __err,
 307                                   tm* __t) const {
 308   typedef string::const_iterator string_iterator;
 309
 310   string_iterator __format = this->_M_timeinfo._M_date_format.begin();
 311   string_iterator __format_end = this->_M_timeinfo._M_date_format.end();
 312
 313   string_iterator __result
 314     = _STLP_PRIV __get_formatted_time(__s, __end, __format, __format_end,
 315                                       __STATIC_CAST(_Ch*, 0), this->_M_timeinfo,
 316                                       __str, __err, __t);
 317   if (__result == __format_end)
 318     __err = ios_base::goodbit;
 319   else {
 320     __err = ios_base::failbit;
 321     if (__s == __end)
 322       __err |= ios_base::eofbit;
 323   }
 324   return __s;
 325 }
 326
 327 template <class _Ch, class _InIt>
 328 _InIt
 329 time_get<_Ch, _InIt>::do_get_time(_InIt __s, _InIt  __end,
 330                                   ios_base& __str, ios_base::iostate&  __err,
 331                                   tm* __t) const {
 332   typedef string::const_iterator string_iterator;
 333   string_iterator __format = this->_M_timeinfo._M_time_format.begin();
 334   string_iterator __format_end = this->_M_timeinfo._M_time_format.end();
 335
 336   string_iterator __result
 337     = _STLP_PRIV __get_formatted_time(__s, __end, __format, __format_end,
 338                                       __STATIC_CAST(_Ch*, 0), this->_M_timeinfo,
 339                                       __str, __err, __t);
 340   __err = __result == __format_end ? ios_base::goodbit
 341                                    : ios_base::failbit;
 342   if (__s == __end)
 343     __err |= ios_base::eofbit;
 344   return __s;
 345 }
 346
 347 template <class _Ch, class _InIt>
 348 _InIt
 349 time_get<_Ch, _InIt>::do_get_year(_InIt __s, _InIt  __end,
 350                                   ios_base&, ios_base::iostate&  __err,
 351                                   tm* __t) const {
 352   if (__s == __end) {
 353     __err = ios_base::failbit | ios_base::eofbit;
 354     return __s;
 355   }
 356
 357   bool __pr =  _STLP_PRIV __get_decimal_integer(__s, __end, __t->tm_year, __STATIC_CAST(_Ch*, 0));
 358   __t->tm_year -= 1900;
 359   __err = __pr ? ios_base::goodbit : ios_base::failbit;
 360   if (__s == __end)
 361     __err |= ios_base::eofbit;
 362
 363   return __s;
 364 }
 365
 366 template <class _Ch, class _InIt>
 367 _InIt
 368 time_get<_Ch, _InIt>::do_get_weekday(_InIt __s, _InIt  __end,
 369                                      ios_base &__str, ios_base::iostate &__err,
 370                                      tm *__t) const {
 371   bool __result =
 372     _STLP_PRIV __get_short_or_long_dayname(__s, __end, this->_M_timeinfo, __t);
 373   if (__result)
 374     __err = ios_base::goodbit;
 375   else {
 376     __err = ios_base::failbit;
 377     if (__s == __end)
 378       __err |= ios_base::eofbit;
 379   }
 380   return __s;
 381 }
 382
 383 template <class _Ch, class _InIt>
 384 _InIt
 385 time_get<_Ch, _InIt>::do_get_monthname(_InIt __s, _InIt  __end,
 386                                        ios_base &__str, ios_base::iostate &__err,
 387                                        tm *__t) const {
 388   bool __result =
 389     _STLP_PRIV __get_short_or_long_monthname(__s, __end, this->_M_timeinfo, __t);
 390   if (__result)
 391     __err = ios_base::goodbit;
 392   else {
 393     __err = ios_base::failbit;
 394     if (__s == __end)
 395       __err |= ios_base::eofbit;
 396   }
 397   return __s;
 398 }
 399
 400 template<class _Ch, class _OutputIter>
 401 _OutputIter
 402 time_put<_Ch,_OutputIter>::put(_OutputIter __s, ios_base& __f, _Ch __fill,
 403                                const tm* __tmb, const _Ch* __pat,
 404                                const _Ch* __pat_end) const {
 405   const ctype<_Ch>& _Ct = use_facet<ctype<_Ch> >(__f.getloc());
 406   while (__pat != __pat_end) {
 407     char __c = _Ct.narrow(*__pat, 0);
 408     if (__c == '%') {
 409       char __mod = 0;
 410       ++__pat;
 411       __c = _Ct.narrow(*__pat++, 0);
 412       if (__c == '#') { // MS extension
 413         __mod = __c;
 414         __c = _Ct.narrow(*__pat++, 0);
 415       }
 416       __s = do_put(__s, __f, __fill, __tmb, __c, __mod);
 417     }
 418     else
 419       *__s++ = *__pat++;
 420   }
 421   return __s;
 422 }
 423
 424 template<class _Ch, class _OutputIter>
 425 _OutputIter
 426 time_put<_Ch,_OutputIter>::do_put(_OutputIter __s, ios_base& __f, _Ch /* __fill */,
 427                                   const tm* __tmb, char __format,
 428                                   char __modifier ) const {
 429   const ctype<_Ch>& __ct = use_facet<ctype<_Ch> >(__f.getloc());
 430   _STLP_BASIC_IOSTRING(_Ch) __buf;
 431   _STLP_PRIV __write_formatted_time(__buf, __ct, __format, __modifier, this->_M_timeinfo, __tmb);
 432   return copy(__buf.begin(), __buf.end(), __s);
 433 }
 434
 435 _STLP_END_NAMESPACE
 436
 437 #endif /* _STLP_TIME_FACETS_C */
 438
 439 // Local Variables:
 440 // mode:C++
 441 // End: