/*

 * © Portions copyright (c) 2006-2007 Nokia Corporation.  All rights reserved.

 *

 * Copyright (c) 1999

 * Silicon Graphics Computer Systems, Inc.

 *

 * Copyright (c) 1999 

 * Boris Fomitchev

 *

 * This material is provided "as is", with absolutely no warranty expressed

 * or implied. Any use is at your own risk.

 *

 * Permission to use or copy this software for any purpose is hereby granted 

 * without fee, provided the above notices are retained on all copies.

 * Permission to modify the code and to distribute modified code is granted,

 * provided the above notices are retained, and a notice that the code was

 * modified is included with the above copyright notice.

 *

 */ 

#ifndef _STLP_TIME_FACETS_C

#define _STLP_TIME_FACETS_C

#ifndef _STLP_INTERNAL_TIME_FACETS_H

# include <stl/_time_facets.h>

#endif

#if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION)

#ifndef _STLP_INTERNAL_NUM_PUT_H

# include <stl/_num_put.h>

#endif

#ifndef _STLP_INTERNAL_NUM_GET_H

# include <stl/_num_get.h>

#endif

_STLP_BEGIN_NAMESPACE

//----------------------------------------------------------------------

// Declarations of static template members.

# if ( _STLP_STATIC_TEMPLATE_DATA > 0 )

# if !defined(__LIBSTD_CPP_SYMBIAN32_WSD__) && !defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_)

template <class _CharT, class _InputIterator>

locale::id time_get<_CharT, _InputIterator>::id;

template <class _CharT, class _OutputIterator>

locale::id time_put<_CharT, _OutputIterator>::id;

#endif

# else /* ( _STLP_STATIC_TEMPLATE_DATA > 0 ) */

typedef time_get<char, const char*> time_get_char;

typedef time_get<char, char*> time_get_char_2;

typedef time_get<char, istreambuf_iterator<char, char_traits<char> > > time_get_char_3;

typedef time_put<char, const char*> time_put_char;

typedef time_put<char, char*> time_put_char_2;

typedef time_put<char, ostreambuf_iterator<char, char_traits<char> > > time_put_char_3;

#ifndef __SYMBIAN32__

__DECLARE_INSTANCE(locale::id, time_get_char::id, );

__DECLARE_INSTANCE(locale::id, time_get_char_2::id, );

__DECLARE_INSTANCE(locale::id, time_get_char_3::id, );

__DECLARE_INSTANCE(locale::id, time_put_char::id, );

__DECLARE_INSTANCE(locale::id, time_put_char_2::id, );

__DECLARE_INSTANCE(locale::id, time_put_char_3::id, );

#endif

# ifndef _STLP_NO_WCHAR_T

typedef time_get<wchar_t, const wchar_t*> time_get_wchar_t;

typedef time_get<wchar_t, wchar_t*> time_get_wchar_t_2;

typedef time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > > time_get_wchar_t_3;

typedef time_put<wchar_t, const wchar_t*> time_put_wchar_t;

typedef time_put<wchar_t, wchar_t*> time_put_wchar_t_2;

typedef time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > > time_put_wchar_t_3;

#ifndef __SYMBIAN32__

__DECLARE_INSTANCE(locale::id, time_get_wchar_t::id, );

__DECLARE_INSTANCE(locale::id, time_get_wchar_t_2::id, );

__DECLARE_INSTANCE(locale::id, time_get_wchar_t_3::id, );

__DECLARE_INSTANCE(locale::id, time_put_wchar_t::id, );

__DECLARE_INSTANCE(locale::id, time_put_wchar_t_2::id, );

__DECLARE_INSTANCE(locale::id, time_put_wchar_t_3::id, );

#endif

# endif

# endif /* ( _STLP_STATIC_TEMPLATE_DATA > 0 ) */

template <class _InIt, class _RAIt, class _DiffType>

_RAIt _STLP_CALL

__match(_InIt& __first, _InIt& __last, _RAIt __name, _RAIt __name_end, _DiffType*) {

  typedef _DiffType difference_type;

  difference_type __n = __name_end - __name;

  size_t __max_pos = 0;

  difference_type __i;

  difference_type __pos = 0;

  difference_type __check_count = __n;

  bool __do_check[_MAXNAMES];

  _RAIt __matching_name[_MAX_NAME_LENGTH];

  for (__i = 0; __i < __n; ++__i)

    __max_pos = (max)(__max_pos,  __name[__i].size());

  for (__i = 0; __i < _MAXNAMES; ++__i)

    __do_check[__i] = true;

  for (__i = 0; __i < _MAX_NAME_LENGTH; ++__i)

    __matching_name[__i] = __name_end;

  while (__first != __last) {

    for (__i = 0; __i < __n; ++__i)

      if (__do_check[__i])

        if (*__first == __name[__i][__pos]) {

          if (__pos == _DiffType(__name[__i].size()) - 1) {

            __do_check[__i] = 0;

            __matching_name[__pos+1] = __name + __i;

            --__check_count;

            if (__check_count == 0) {

              ++__first; 

	      return __name + __i;

	    }

          }

        }

        else {

          __do_check[__i] = 0;

          --__check_count;

          if (__check_count == 0) 

            return __matching_name[__pos];

        }

    ++__first; ++__pos;

  }

  return __matching_name[__pos];

}

template <class _InIt, class _RAIt>

_RAIt _STLP_CALL

__match(_InIt& __first, _InIt& __last, _RAIt __name, _RAIt __name_end) {

  return __match((_InIt&)__first, (_InIt&)__last, __name, __name_end, _STLP_DISTANCE_TYPE(__name, _InIt));

}

// __get_formatted_time reads input that is assumed to be formatted

// according to the rules for the C strftime function (C standard,

// 7.12.3.5).  This function is used to implement the do_get_time

// and do_get_date virtual functions, which depend on the locale

// specifications for the time and day formats respectively.

// Note the catchall default case, intended mainly for the '%Z'

// format designator, which does not make sense here since the

// representation of timezones is not part of the locale.

//

// The case branches are implemented either by doing a match using

// the appopriate name table or by doing a __get_integer_nogroup.

//

// 'y' format is assumed to mean that the input represents years

// since 1900.  That is, 2002 should be represented as 102.  There

// is no century-guessing.

//

// The match is successful if and only if the second component of the

// return value is format_end.

// Note that the antepenultimate parameter is being used only to determine

// the correct overloading for the calls to __get_integer_nogroup.

template <class _InIt1, class _InIt2 /* , class _Ch */ >

_InIt2 _STLP_CALL

__get_formatted_time _STLP_WEAK (_InIt1 __first,  _InIt1 __last,

                     _InIt2 __format, _InIt2 __format_end,

				 /* _Ch, */ const _Time_Info& __table,

		     ios_base::iostate& __err,

                     tm*         __t) {

  while(__first != __last && __format != __format_end) {

    if (*__format == '%') {

      ++__format;

      char __c = *__format;

      switch (__c) {

        case 'a': {

          const string* __pr =

            __match(__first, __last,

		    (string*)__table._M_dayname + 0 , (string*)__table._M_dayname + 7);

            if (__pr == (string*)__table._M_dayname + 7)

              return __format;

            __t->tm_wday = (int)(__pr - (string*)__table._M_dayname);

            break;

        }

        case 'A': {

          const string* __pr =

            __match(__first, __last,

		    (string*)__table._M_dayname + 7, (string*)__table._M_dayname + 14);

            if (__pr == (string*)__table._M_dayname + 14)

              return __format;

            __t->tm_wday = (int)(__pr - (string*)__table._M_dayname - 7);

            break;

        }

        case 'b': {

          const string* __pr =

            __match(__first, __last,

		    (string*)__table._M_monthname + 0, (string*)__table._M_monthname + 12);

            if (__pr == (string*)__table._M_monthname + 12)

              return __format;

            __t->tm_mon = (int)(__pr - (string*)__table._M_monthname);

            break;

        }

        case 'B': {

          const string* __pr =

            __match(__first, __last,

		    (string*)__table._M_monthname + 12, (string*)__table._M_monthname + 24);

            if (__pr == (string*)__table._M_monthname + 24)

              return __format;

            __t->tm_mon = (int)(__pr - (string*)__table._M_monthname - 12);

            break;

        }

        case 'd': {

          bool __pr =

            __get_decimal_integer(__first, __last, __t->tm_mday);

          if (!__pr || __t->tm_mday < 1 || __t->tm_mday > 31) {

	    __err |= ios_base::failbit;

            return __format;

	  }

          break;

        }

        case 'H': case 'I': {

          bool __pr =

            __get_decimal_integer(__first, __last, __t->tm_hour);

            if (!__pr)

              return __format;

            break;

        }

        case 'j': {

          bool __pr =

            __get_decimal_integer(__first, __last, __t->tm_yday);

          if (!__pr)

            return __format;

          break;

        }

        case 'm': {

          bool __pr =

            __get_decimal_integer(__first, __last, __t->tm_mon);

	    --__t->tm_mon;

          if (!__pr || __t->tm_mon < 0 || __t->tm_mon > 11) {

	    __err |= ios_base::failbit;

            return __format;

	  }

          break;

        }

        case 'M': {

          bool __pr =

            __get_decimal_integer(__first, __last, __t->tm_min);

          if (!__pr)

            return __format;

          break;

        }

        case 'p': {

          const string* __pr =

            __match(__first, __last, (string*)__table._M_am_pm + 0, (string*)__table._M_am_pm + 2);

          if (__pr == (string*)__table._M_am_pm + 2)

            return __format;

          if (__pr == (string*)__table._M_am_pm + 1)

            __t->tm_hour += 12;

          break;

        }

        case 'S': {

          bool __pr =

            __get_decimal_integer(__first, __last, __t->tm_sec);

          if (!__pr)

            return __format;

          break;

        }

	case 'y': {

	  bool __pr =

	    __get_decimal_integer(__first, __last, __t->tm_year);

	  if (!__pr)

	    return __format;

	  break;

        }

        case 'Y': {

	  bool __pr =

            __get_decimal_integer(__first, __last, __t->tm_year);

          __t->tm_year -= 1900;

          if (!__pr)

            return __format;

          break;

        }

        default:

          break;

      }

    }

    else {

      if (*__first != *__format) 

	  	break;

	 __first++;

    }

    ++__format;

  }

  return __format;

}

template <class _InIt>

bool _STLP_CALL

__get_short_or_long_dayname(_InIt& __first, _InIt& __last,

                            const _Time_Info& __table, tm* __t) {

  const string* __pr =

    __match(__first, __last, __table._M_dayname + 0, __table._M_dayname + 14);

  __t->tm_wday = (int)(__pr - __table._M_dayname) % 7;

  return __pr != __table._M_dayname + 14;

}

template <class _InIt>

bool _STLP_CALL

__get_short_or_long_monthname(_InIt& __first, _InIt& __last,

                              const _Time_Info& __table, tm* __t) {

  const string* __pr =

    __match(__first, __last, (string*)__table._M_monthname + 0, (string*)__table._M_monthname + 24);

  __t->tm_mon = (int)(__pr - __table._M_monthname) % 12;

  return __pr != __table._M_monthname + 24;

}

# ifndef _STLP_NO_WCHAR_T

template <class _OuIt>

_OuIt _STLP_CALL

__put_time(char * __first, char * __last, _OuIt __stl_out,

           const ios_base& __s, wchar_t) {

    //const ctype<wchar_t>& __ct = *(ctype<wchar_t>*)__s._M_ctype_facet();

    const ctype<wchar_t>& __ct = use_facet< ctype<wchar_t> >(__s.getloc());

    wchar_t __wbuf[64];

    __ct.widen(__first, __last, __wbuf);

    ptrdiff_t __len = __last - __first;

    wchar_t * __eend = __wbuf + __len;

    return copy((wchar_t*)__wbuf, __eend, __stl_out);

}

# endif

#ifdef	__SYMBIAN32__

template <class _CharT, class _OuIt>

_OuIt _STLP_CALL

__put_time(char * __first, char * __last, _OuIt __stl_out,

           const ios_base& __s, _CharT) {

    //const ctype<wchar_t>& __ct = *(ctype<wchar_t>*)__s._M_ctype_facet();

    const ctype<_CharT>& __ct = use_facet< ctype<_CharT> >(__s.getloc());

    _CharT __wbuf[64];

    __ct.widen(__first, __last, __wbuf);

    ptrdiff_t __len = __last - __first;

    _CharT * __eend = __wbuf + __len;

    return copy((_CharT*)__wbuf, __eend, __stl_out);

}

#endif

template <class _Ch, class _InIt>

_InIt

time_get<_Ch, _InIt>::do_get_date(_InIt __s, _InIt  __end,

				  ios_base& /* __str */, ios_base::iostate&  __err,

				  tm* __t) const 

{

  typedef string::const_iterator string_iterator;

  string_iterator __format

    = _M_timeinfo._M_date_format.begin();

  string_iterator __format_end

    = _M_timeinfo._M_date_format.end();

  string_iterator __result

    = __get_formatted_time(__s, __end, __format, __format_end,

                           /* _Ch() ,*/  _M_timeinfo, __err, __t);

  if (__result == __format_end)

    __err = ios_base::goodbit;

  else {

    __err = ios_base::failbit;

    if (__s == __end)

      __err |= ios_base::eofbit;

  }

  return __s;

}

template <class _Ch, class _InIt>

_InIt

time_get<_Ch, _InIt>::do_get_time(_InIt __s, _InIt  __end,

				  ios_base& /* __str */, ios_base::iostate&  __err,

				  tm* __t) const 

{

  typedef string::const_iterator string_iterator;

  string_iterator __format

    = _M_timeinfo._M_time_format.begin();

  string_iterator __format_end

    = _M_timeinfo._M_time_format.end();

  string_iterator __result

    = __get_formatted_time(__s, __end, __format, __format_end,

			   /* _Ch() , */ _M_timeinfo, __err, __t);

  __err = __result == __format_end ? ios_base::goodbit 

    : ios_base::failbit;

  if (__s == __end)

    __err |= ios_base::eofbit;

  return __s;

}

template <class _Ch, class _InIt>

_InIt

time_get<_Ch, _InIt>::do_get_year(_InIt __s, _InIt  __end,

				  ios_base&, 

				  ios_base::iostate&  __err,

				  tm* __t) const

{

  if (__s == __end) {

    __err = ios_base::failbit | ios_base::eofbit;

    return __s;

  }

  bool __pr =  __get_decimal_integer(__s, __end, __t->tm_year);

  __t->tm_year -= 1900;

  __err = __pr ? ios_base::goodbit : ios_base::failbit;

  if (__s == __end)

    __err |= ios_base::eofbit;

  return __s;

}

template <class _Ch, class _InIt>

_InIt

time_get<_Ch, _InIt>::do_get_weekday(_InIt __s, _InIt  __end,

				     ios_base& /* __str */, 

				     ios_base::iostate&  __err,

				     tm* __t) const 

{

    bool __result =

      __get_short_or_long_dayname(__s, __end, _M_timeinfo, __t);

    if (__result)

      __err = ios_base::goodbit;

    else {

      __err = ios_base::failbit;

      if (__s == __end)

        __err |= ios_base::eofbit;

    }

    return __s;

}

template <class _Ch, class _InIt>

_InIt

time_get<_Ch, _InIt>::do_get_monthname(_InIt __s, _InIt  __end,

				       ios_base& /* __str */, 

				       ios_base::iostate&  __err,

				       tm* __t) const 

{

  bool __result =

    __get_short_or_long_monthname(__s, __end, _M_timeinfo, __t);

  if (__result)

    __err = ios_base::goodbit;

  else {

    __err = ios_base::failbit;

    if (__s == __end)

      __err |= ios_base::eofbit;

  }

  return __s;

}

template<class _Ch, class _OutputIter>

_OutputIter

time_put<_Ch,_OutputIter>::put(_OutputIter __s, ios_base& __f, _Ch __fill,

			       const tm* __tmb,

			       const _Ch* __pat, const _Ch* __pat_end) const 

{

    locale __loc = __f.getloc();

    const ctype<_Ch>& _Ct = use_facet<ctype<_Ch> >(__loc); 

 // const ctype<_Ch>& _Ct = *(ctype<_Ch>*)__f._M_ctype_facet(); 

  while (__pat != __pat_end) {

    char __c = _Ct.narrow(*__pat, 0);

    if (__c == '%') {

      char __mod = 0;

      ++__pat;

      __c = _Ct.narrow(*__pat++, 0);

      if(__c == '#') { // MS extension

        __mod = __c;

        __c = _Ct.narrow(*__pat++, 0);

      }

      __s = do_put(__s, __f, __fill, __tmb, __c, __mod);

    }

    else

      *__s++ = *__pat++;

  }

  return __s;

}

template<class _Ch, class _OutputIter>

_OutputIter

time_put<_Ch,_OutputIter>::do_put(_OutputIter __s, ios_base& __f, _Ch     /* __fill */ ,

				  const tm* __tmb,

				  char __format, char __modifier ) const 

{

  char __buf[64];

  char * __iend = __write_formatted_time(__buf, __format, __modifier,

					 _M_timeinfo, __tmb);

  //  locale __loc = __f.getloc();

  return __put_time(__buf, __iend, __s, __f, _Ch());

}

_STLP_END_NAMESPACE

# endif /* defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) */

#endif /* _STLP_TIME_FACETS_C */

// Local Variables:

// mode:C++

// End: