// -*- C++ -*-
/***************************************************************************
 *
 * numeral - Declarations for the Standard Library numeric facets
 *
 ***************************************************************************
 *    
 *  Copyright 2000 Compaq Computer Corporation
 *
 *  COMPAQ Registered in U.S. Patent and Trademark Office.
 *
 *  Confidential computer software. Valid license from Compaq required for
 *  possession, use or copying. Consistent with FAR 12.211 and 12.212,
 *  Commercial Computer Software, Computer Software Documentation, and
 *  Technical Data for Commercial Items are licensed to the U.S. Government
 *  under vendor's standard commercial license.
 *
 ****************************************************************************
 *
 * (c) Copyright 1994, 1998 Rogue Wave Software, Inc.
 * ALL RIGHTS RESERVED
 *
 * The software and information contained herein are proprietary to, and
 * comprise valuable trade secrets of, Rogue Wave Software, Inc., which
 * intends to preserve as trade secrets such software and information.
 * This software is furnished pursuant to a written license agreement and
 * may be used, copied, transmitted, and stored only in accordance with
 * the terms of such license and with the inclusion of the above copyright
 * notice.  This software and information or any other copies thereof may
 * not be provided or otherwise made available to any other person.
 *
 * Notwithstanding any other lease or license that may pertain to, or
 * accompany the delivery of, this computer software and information, the
 * rights of the Government regarding its use, reproduction and disclosure
 * are as set forth in Section 52.227-19 of the FARS Computer
 * Software-Restricted Rights clause.
 * 
 * Use, duplication, or disclosure by the Government is subject to
 * restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in
 * Technical Data and Computer Software clause at DFARS 252.227-7013.
 * Contractor/Manufacturer is Rogue Wave Software, Inc.,
 * P.O. Box 2328, Corvallis, Oregon 97339.
 *
 * This computer software and information is distributed with "restricted
 * rights."  Use, duplication or disclosure is subject to restrictions as
 * set forth in NASA FAR SUP 18-52.227-79 (April 1985) "Commercial
 * Computer Software-Restricted Rights (April 1985)."  If the Clause at
 * 18-52.227-74 "Rights in Data General" is specified in the contract,
 * then the "Alternate III" clause applies.
 *
 **************************************************************************/

#ifndef __STD_NUMERAL__
#define __STD_NUMERAL__ 1

#ifndef __STD_RWLOCALE__
#include <rwlocale>
#endif

#ifndef __STD_IOSBASE__
#include <iosbase>
#endif

#ifndef __STD_LIMITS
#include <limits>
#endif

#if defined(__DECCXX)
#   ifdef __PRAGMA_ENVIRONMENT
#      pragma __environment __save
#      pragma __environment __header_defaults
#   endif
#endif

#if defined(__VMS) && defined(__DECCXX) && !defined(__DECFIXCXXL1158)
#pragma __extern_prefix __save
#pragma __extern_prefix "CXXL$" 
#endif


#ifndef _RWSTD_NO_NAMESPACE
namespace _RWrwstd {
#endif

// ------------------------------------------------------
// Implementation class template -- numpunct_init<charT>.
// ------------------------------------------------------

// Structure used to initialize a rwstd::numpunct_data.

template <class charT>
class _RWSTDExportTemplate numpunct_init {
 public:
  bool del_;                    // Kill the bearer of this message
  charT dp_, ts_;               // Decimal point and thousands separator
  const char *gr_;              // Digit grouping rule
  const charT *tn_, *fn_;       // Strings for boolean true and false
};

// --------------------------------------
// Implementation class -- numpunct_base.
// --------------------------------------

// Contains parts of numpunct<charT> that don't depend on the charT template
// parameter.

class _RWSTDExport numpunct_base {
 public:
  static numpunct_init<char> *get_named_init_ (const char*);
};

// ------------------------------------------------------
// Implementation class template -- numpunct_data<charT>.
// ------------------------------------------------------

// numpunct<charT> derives from this (via rwstd::numpunct_impl) to get its
// private data members.

template <class charT>
class _RWSTDExportTemplate numpunct_data :
    public numpunct_base,
    public punct_data<charT>
{
#ifndef _RWSTD_NO_NAMESPACE
  friend class _RW_STD::numpunct<charT>;
#else
  friend class numpunct<charT>;
#endif
  friend class keyword_cracker<charT>;

  typedef _RW_STD::basic_string<charT,_RW_STD::char_traits<charT>,_RW_STD::allocator<charT> > string_type;

  string_type tn_, fn_;

  keyword_def<charT> tf_defs_[2];
  keyword_map<charT> tf_map_;

 protected:
  numpunct_data (const numpunct_init<charT>*);
  numpunct_init<charT> *get_init_by_name_ (const char*);

#if defined(__DECCXX) && !defined(__DECFIXCXXL957)
  void _RWinitfacet_base (const locale*);
#else
  void _RWinit_facet_base (const locale*);
#endif
};

template <class charT>
inline numpunct_data<charT>::numpunct_data
    (const numpunct_init<charT> *init)
{
  if (!init) {
    this->dp_=charT('.');
    this->ts_=charT(',');
  } else {
    this->dp_=init->dp_;
    this->ts_=init->ts_;
    this->gr_=init->gr_;
    tn_=init->tn_;
    fn_=init->fn_;

    if (init->del_)
      delete[] (char*) init;
  }
}

template <class charT>
numpunct_init<charT>* _RWSTDExportTemplate
fixup_numpunct_init
    (numpunct_init<char>*,charT*);

#ifndef _RWSTD_NO_NEW_TEMPLATE_SYNTAX
template <>
inline numpunct_init<char>* 
fixup_numpunct_init<char>(numpunct_init<char> *init,char*)
#else
inline numpunct_init<char>* 
fixup_numpunct_init(numpunct_init<char> *init,char*)
#endif // _RWSTD_NO_NEW_TEMPLATE_SYNTAX
{  return init; }

// ------------------------------------------------------
// Implementation class template -- numpunct_impl<charT>.
// ------------------------------------------------------

// numpunct<charT> derives from this to obtain the part of its behavior that
// must be specialized for char and wchar_t.  This lets us avoid specializing
// the whole numpunct<charT> template.  Currently the only specialized behavior
// is the initialization of private data members in the constructor.

template <class charT>
class _RWSTDExportTemplate numpunct_impl :
    public numpunct_data<charT>
{
 protected:
  numpunct_impl (const numpunct_init<charT>* init)
   : numpunct_data<charT>(init) { }
 public:
  static const numpunct_init<charT> *get_ivals_ ()
    { return NULL; }
};

_RWSTD_TEMPLATE
class _RWSTDExport numpunct_impl<char>:                  // Specialization
    public numpunct_data<char>
{
#ifndef _MSC_VER
  static _RWSTDExport numpunct_init<char> ivals_;        // Vendor-supplied
#else
  static numpunct_init<char> ivals_;
#endif

 protected:
  numpunct_impl
      (const numpunct_init<char> *init):
       numpunct_data<char>(init) { }
 public:
  static const numpunct_init<char> *get_ivals_ ()
    { return &ivals_; }
};

#ifndef _RWSTD_NO_WIDE_CHAR
_RWSTD_TEMPLATE
class _RWSTDExport numpunct_impl<wchar_t>:               // Specialization
    public numpunct_data<wchar_t>
{
#ifndef _MSC_VER
  static _RWSTDExport numpunct_init<wchar_t> ivals_;     // Vendor-supplied
#else
  static numpunct_init<wchar_t> ivals_;
#endif

 protected:
  numpunct_impl
      (const numpunct_init<wchar_t> *init):
       numpunct_data<wchar_t>(init) { }
 public:
  static const numpunct_init<wchar_t> *get_ivals_ ()
    { return &ivals_; }
};
#endif // _RWSTD_NO_WIDE_CHAR

#ifndef _RWSTD_NO_NAMESPACE
} namespace std {
#endif

// ---------------------------------------------------------------
// Standard numeric parsing facet -- num_get<charT,InputIterator>.
// ---------------------------------------------------------------

template <class charT, class InputIterator>
class num_get: public locale::facet
{
 public:
  typedef charT char_type;
  typedef InputIterator iter_type;

  _EXPLICIT num_get (size_t refs=0): locale::facet(refs,locale::numeric) { }

#ifndef _RWSTD_NO_BOOL
  iter_type get (iter_type i, iter_type e, ios_base &f, ios_base::iostate &err,
                 bool& v) const            { return do_get(i,e,f,err,v); }
#endif
  iter_type get (iter_type i, iter_type e, ios_base &f, ios_base::iostate &err,
                 long& v) const            { return do_get(i,e,f,err,v); }
  iter_type get (iter_type i, iter_type e, ios_base &f, ios_base::iostate &err,
                 unsigned short& v) const  { return do_get(i,e,f,err,v); }
  iter_type get (iter_type i, iter_type e, ios_base &f, ios_base::iostate &err,
                 unsigned int& v) const    { return do_get(i,e,f,err,v); }
  iter_type get (iter_type i, iter_type e, ios_base &f, ios_base::iostate &err,
                 unsigned long& v) const   { return do_get(i,e,f,err,v); }
  iter_type get (iter_type i, iter_type e, ios_base &f, ios_base::iostate &err,
                 float& v) const           { return do_get(i,e,f,err,v); }
  iter_type get (iter_type i, iter_type e, ios_base &f, ios_base::iostate &err,
                 double& v) const          { return do_get(i,e,f,err,v); }
  iter_type get (iter_type i, iter_type e, ios_base &f, ios_base::iostate &err,
                 long double& v) const     { return do_get(i,e,f,err,v); }
  iter_type get (iter_type i, iter_type e, ios_base &f, ios_base::iostate &err,
                 void*& p) const           { return do_get(i,e,f,err,p); }

  static locale::id id;

  // Extension for compilers that have an extra-long integer type:
#ifdef _RWSTD_LONG_LONG
  iter_type get (iter_type i, iter_type e, ios_base &f, ios_base::iostate &err,
                 _RWSTD_LONG_LONG& v) const 
  { return do_get(i,e,f,err,v); }
  iter_type get (iter_type i, iter_type e, ios_base &f, ios_base::iostate &err,
                 unsigned _RWSTD_LONG_LONG& v) const 
  { return do_get(i,e,f,err,v); }
#endif

  // Implementation:
  enum { _RWfacet_cat = locale::numeric, _RWok_implicit = 1 };

 protected:
  virtual ~num_get();

#ifndef _RWSTD_NO_BOOL
  virtual iter_type do_get (iter_type, iter_type, ios_base&,
                            ios_base::iostate& err, bool& v) const;
#endif
  virtual iter_type do_get (iter_type, iter_type, ios_base&,
                            ios_base::iostate& err, long& v) const;
  virtual iter_type do_get (iter_type, iter_type, ios_base&,
                            ios_base::iostate& err, unsigned short& v) const;
  virtual iter_type do_get (iter_type, iter_type, ios_base&,
                            ios_base::iostate& err, unsigned int& v) const;
  virtual iter_type do_get (iter_type, iter_type, ios_base&,
                            ios_base::iostate& err, unsigned long& v) const;
  virtual iter_type do_get (iter_type, iter_type, ios_base&,
                            ios_base::iostate& err, float& v) const;
  virtual iter_type do_get (iter_type, iter_type, ios_base&,
                            ios_base::iostate& err, double& v) const;
  virtual iter_type do_get (iter_type, iter_type, ios_base&,
                            ios_base::iostate& err, long double& v) const;
  virtual iter_type do_get (iter_type, iter_type, ios_base&,
                            ios_base::iostate& err, void*& p) const;

#ifdef _RWSTD_LONG_LONG
  virtual iter_type do_get (iter_type, iter_type, ios_base&,
                            ios_base::iostate& err, 
                            _RWSTD_LONG_LONG& v) const;
  virtual iter_type do_get (iter_type, iter_type, ios_base&,
                            ios_base::iostate& err, 
                            unsigned _RWSTD_LONG_LONG& v) const;
#endif

  // Implementation:

 private:
  #ifdef _RWSTD_NO_MEMBER_TEMPLATES
  locale::id &_RWget_id (void) const { return id; }
  #endif
};

// -------------------------------------------------------------------
// Standard numeric formatting facet -- num_put<charT,OutputIterator>.
// -------------------------------------------------------------------

template <class charT, class OutputIterator>
class num_put: public locale::facet {
 public:
  typedef charT char_type;
  typedef OutputIterator iter_type;

  _EXPLICIT num_put (size_t refs=0): locale::facet(refs,locale::numeric) { }

#ifndef _RWSTD_NO_BOOL
  iter_type put (iter_type s, ios_base& f, char_type fill, bool v)
                 const { return do_put(s,f,fill,v); }
#endif
  iter_type put (iter_type s, ios_base& f, char_type fill, long v)
                 const { return do_put(s,f,fill,v); }
  iter_type put (iter_type s, ios_base& f, char_type fill, unsigned long v)
                 const { return do_put(s,f,fill,v); }
  iter_type put (iter_type s, ios_base& f, char_type fill, double v)
                 const { return do_put(s,f,fill,v); }
  iter_type put (iter_type s, ios_base& f, char_type fill, long double v)
                 const { return do_put(s,f,fill,v); }
  iter_type put (iter_type s, ios_base& f, char_type fill, const void* p)
                 const { return do_put(s,f,fill,p); }

  // Rogue Wave extensions.
#ifdef __TURBOC__
  iter_type put (iter_type s, ios_base& f, char_type fill, float v)
                 const { return do_put(s,f,fill,(double)v); }
#endif
  iter_type put (iter_type s, ios_base& f, char_type fill, short v)
                 const { return do_put(s,f,fill,v); }
  iter_type put (iter_type s, ios_base& f, char_type fill, unsigned short v)
                 const { return do_put(s,f,fill,v); }
  iter_type put (iter_type s, ios_base& f, char_type fill, int v)
                 const { return do_put(s,f,fill,v); }
  iter_type put (iter_type s, ios_base& f, char_type fill, unsigned int v)
                 const { return do_put(s,f,fill,v); }

#ifdef _RWSTD_LONG_LONG
  iter_type put (iter_type s, ios_base& f, char_type fill, 
                 _RWSTD_LONG_LONG v) const 
  { return do_put(s,f,fill,v); }
  iter_type put (iter_type s, ios_base& f, char_type fill, 
                 unsigned _RWSTD_LONG_LONG v) const 
  { return do_put(s,f,fill,v); }
#endif

  static locale::id id;

  // Implementation:
  enum { _RWfacet_cat = locale::numeric, _RWok_implicit = 1 };

 protected:
  virtual ~num_put();

#ifndef _RWSTD_NO_BOOL
  virtual iter_type do_put (iter_type, ios_base&, char_type fill,
                            bool v) const;
#endif
  virtual iter_type do_put (iter_type, ios_base&, char_type fill,
                            long v) const;
  virtual iter_type do_put (iter_type, ios_base&, char_type fill,
                            unsigned long v) const;
  virtual iter_type do_put (iter_type, ios_base&, char_type fill,
                            double v) const;
  virtual iter_type do_put (iter_type, ios_base&, char_type fill,
                            long double v) const;
  virtual iter_type do_put (iter_type, ios_base&, char_type fill,
                            const void* p) const;

  // Rogue Wave extensions.
  virtual iter_type do_put (iter_type, ios_base&, char_type fill,
                            short v) const;
  virtual iter_type do_put (iter_type, ios_base&, char_type fill,
                            unsigned short v) const;
  virtual iter_type do_put (iter_type, ios_base&, char_type fill,
                            int v) const;
  virtual iter_type do_put (iter_type, ios_base&, char_type fill,
                            unsigned int v) const;

#ifdef _RWSTD_LONG_LONG
  virtual iter_type do_put (iter_type, ios_base&, char_type fill,
                            _RWSTD_LONG_LONG v) const;
  virtual iter_type do_put (iter_type, ios_base&, char_type fill,
                            unsigned _RWSTD_LONG_LONG v) const;
#endif

  // Implementation.

 private:
  #ifdef _RWSTD_NO_MEMBER_TEMPLATES
  locale::id &_RWget_id (void) const { return id; }
  #endif
};

// ------------------------------------------------------
// Standard numeric punctuation facet -- numpunct<charT>.
// ------------------------------------------------------

template <class charT>
class numpunct: public locale::facet,
    public __RWSTD::numpunct_impl<charT>
{
 public:
  typedef charT char_type;
  typedef basic_string<charT,char_traits<charT>,allocator<charT> >
    string_type;

  // The second parameter (i) to the constructor is implementation specific.
  // For portable code, always let it default as shown.
  _EXPLICIT numpunct (size_t refs=0,
#ifndef _MSC_VER
      const __RWSTD::numpunct_init<charT> *i = __RWSTD::numpunct_impl<charT>::get_ivals_());
#else
      const __RWSTD::numpunct_init<charT> *i = get_ivals_());
#endif


  char_type   decimal_point() const { return do_decimal_point(); }
  char_type   thousands_sep() const { return do_thousands_sep(); }
  string      grouping()      const { return do_grouping(); }
  string_type truename()      const { return do_truename(); }
  string_type falsename()     const { return do_falsename(); }

  static locale::id id;

  // Implementation:
  enum { _RWfacet_cat = locale::numeric, _RWok_implicit = 1 };

 protected:
  virtual ~numpunct();

  virtual char_type   do_decimal_point() const;
  virtual char_type   do_thousands_sep() const;
  virtual string      do_grouping()      const;
  virtual string_type do_truename()      const;
  virtual string_type do_falsename()     const;

  // Implementation:

 private:
#if defined(__DECCXX) && !defined(__DECFIXCXXL957)
  void _RWinitfacet (const locale*);
#else
  void _RWinit_facet (const locale*);
#endif

  #ifdef _RWSTD_NO_MEMBER_TEMPLATES
  locale::id &_RWget_id (void) const { return id; }
  #endif
};

template <class charT>
inline numpunct<charT>::numpunct
    (size_t refs,const __RWSTD::numpunct_init<charT> *init):
     locale::facet(refs,locale::numeric),
     __RWSTD::numpunct_impl<charT>(init)
{ }

// -------------------------------------------------
// Standard derived facet -- numpunct_byname<charT>.
// -------------------------------------------------

template <class charT>
class numpunct_byname: public numpunct<charT> {
 public:
  _EXPLICIT numpunct_byname (const char*, size_t refs=0);

 protected:
  virtual ~numpunct_byname();

// Virtual member functions inherited from numpunct<charT>:
// virtual char_type   do_decimal_point() const;
// virtual char_type   do_thousands_sep() const;
// virtual string      do_grouping() const;
// virtual string_type do_truename() const;
// virtual string_type do_falsename() const;
};

#if defined(__DECCXX) && !defined(__DECFIXCXXL646)

template <>
class _RWSTDExportTemplate numpunct_byname<char> : public numpunct<char> {

 private:
  _LocaleManager* _LocaleManagerPtr;

 public:
  _EXPLICIT numpunct_byname (const char*, size_t refs=0);

 protected:
  virtual ~numpunct_byname();

// Virtual member functions inherited from numpunct<charT>:
// virtual char_type   do_decimal_point() const;
// virtual char_type   do_thousands_sep() const;
// virtual string      do_grouping() const;
// virtual string_type do_truename() const;
// virtual string_type do_falsename() const;
};

// ----------------------------------------------------------
// Standard facet specialization -- numpunct_byname<wchar_t>.
// ----------------------------------------------------------

#ifndef _RWSTD_NO_WIDE_CHAR

template <>
class _RWSTDExportTemplate numpunct_byname<wchar_t> : public numpunct<wchar_t> {

 private:
  _LocaleManager* _LocaleManagerPtr;

 public:
  _EXPLICIT numpunct_byname (const char*, size_t refs=0);

 protected:
  virtual ~numpunct_byname();

  virtual char_type   do_decimal_point() const;
  virtual char_type   do_thousands_sep() const;
  virtual string      do_grouping() const;
  virtual string_type do_truename() const;
  virtual string_type do_falsename() const;
};

#endif // __RWSTD_NO_WIDE_CHAR

#endif

#ifndef _RWSTD_NO_NAMESPACE
} namespace _RWrwstd {
#endif

#ifndef _RWSTD_NO_FUNC_PARTIAL_SPEC
template <class charT>
inline _RW_STD::numpunct<charT>* create_named_facet
    (_RW_STD::numpunct<charT>*,const char *name,size_t refs)
{ return new _RW_STD::numpunct_byname<charT>(name,refs); }
#else

inline _RW_STD::numpunct<char>* create_named_facet
    (_RW_STD::numpunct<char>*,const char *name,size_t refs)
{ return new _RW_STD::numpunct_byname<char>(name,refs); }

#ifndef _RWSTD_NO_WIDE_CHAR
inline _RW_STD::numpunct<wchar_t>* create_named_facet
    (_RW_STD::numpunct<wchar_t>*,const char *name,size_t refs)
{ return new _RW_STD::numpunct_byname<wchar_t>(name,refs); }
#endif
#endif

#ifndef _RWSTD_NO_NAMESPACE
}
#endif

#ifndef __FORCE_INSTANTIATIONS
// locale instantiations
#pragma do_not_instantiate std::numpunct<char>::~numpunct() 
#pragma do_not_instantiate char std::numpunct<char>::do_decimal_point() const
#pragma do_not_instantiate char std::numpunct<char>::do_thousands_sep() const
#pragma do_not_instantiate std::string std::numpunct<char>::do_grouping() const
#pragma do_not_instantiate std::string std::numpunct<char>::do_truename() const
#pragma do_not_instantiate std::string std::numpunct<char>::do_falsename() const

#if defined(__DECCXX) && (defined(__osf__) && (defined(__X_FLOAT) && (__X_FLOAT==1)) || (defined(__vms)  && (__X_FLOAT==0))) 
#else
#pragma do_not_instantiate std::num_get<char, std::istreambuf_iterator<char, std::char_traits<char> > >::~num_get()
#endif
#pragma do_not_instantiate std::istreambuf_iterator<char, std::char_traits<char> > std::num_get<char, std::istreambuf_iterator<char, std::char_traits<char> > >::do_get(std::istreambuf_iterator<char, std::char_traits<char> >, std::istreambuf_iterator<char, std::char_traits<char> >, std::ios_base &, int &, bool &) const
#pragma do_not_instantiate std::istreambuf_iterator<char, std::char_traits<char> > std::num_get<char, std::istreambuf_iterator<char, std::char_traits<char> > >::do_get(std::istreambuf_iterator<char, std::char_traits<char> >, std::istreambuf_iterator<char, std::char_traits<char> >, std::ios_base &, int &, long &) const

#pragma do_not_instantiate std::istreambuf_iterator<char, std::char_traits<char> > std::num_get<char, std::istreambuf_iterator<char, std::char_traits<char> > >::do_get(std::istreambuf_iterator<char, std::char_traits<char> >, std::istreambuf_iterator<char, std::char_traits<char> >, std::ios_base &, int &, unsigned short &) const
#pragma do_not_instantiate std::istreambuf_iterator<char, std::char_traits<char> > std::num_get<char, std::istreambuf_iterator<char, std::char_traits<char> > >::do_get(std::istreambuf_iterator<char, std::char_traits<char> >, std::istreambuf_iterator<char, std::char_traits<char> >, std::ios_base &, int &, unsigned int &) const
#pragma do_not_instantiate std::istreambuf_iterator<char, std::char_traits<char> > std::num_get<char, std::istreambuf_iterator<char, std::char_traits<char> > >::do_get(std::istreambuf_iterator<char, std::char_traits<char> >, std::istreambuf_iterator<char, std::char_traits<char> >, std::ios_base &, int &, unsigned long &) const
#ifdef _RWSTD_LONG_LONG
#pragma do_not_instantiate std::istreambuf_iterator<char, std::char_traits<char> > std::num_get<char, std::istreambuf_iterator<char, std::char_traits<char> > >::do_get(std::istreambuf_iterator<char, std::char_traits<char> >, std::istreambuf_iterator<char, std::char_traits<char> >, std::ios_base &, int &, long long &) const
#pragma do_not_instantiate std::istreambuf_iterator<char, std::char_traits<char> > std::num_get<char, std::istreambuf_iterator<char, std::char_traits<char> > >::do_get(std::istreambuf_iterator<char, std::char_traits<char> >, std::istreambuf_iterator<char, std::char_traits<char> >, std::ios_base &, int &, unsigned long long &) const
#endif

// Force instantiation of non-standard floating point methods
#if (defined(__VMS) && defined(__DECCXX) && !defined(__DECFIXCXXL1247) && (defined(__G_FLOAT) && __G_FLOAT==0))
#else
#pragma do_not_instantiate std::istreambuf_iterator<char, std::char_traits<char> > std::num_get<char, std::istreambuf_iterator<char, std::char_traits<char> > >::do_get(std::istreambuf_iterator<char, std::char_traits<char> >, std::istreambuf_iterator<char, std::char_traits<char> >, std::ios_base &, int &, float &) const 
#pragma do_not_instantiate std::istreambuf_iterator<char, std::char_traits<char> > std::num_get<char, std::istreambuf_iterator<char, std::char_traits<char> > >::do_get(std::istreambuf_iterator<char, std::char_traits<char> >, std::istreambuf_iterator<char, std::char_traits<char> >, std::ios_base &, int &, double &) const
#if defined(__DECCXX) && (defined(__osf__) && (defined(__X_FLOAT) && (__X_FLOAT==1)) || (defined(__vms)  && (__X_FLOAT==0))) 
#else
#pragma do_not_instantiate std::istreambuf_iterator<char, std::char_traits<char> > std::num_get<char, std::istreambuf_iterator<char, std::char_traits<char> > >::do_get(std::istreambuf_iterator<char, std::char_traits<char> >, std::istreambuf_iterator<char, std::char_traits<char> >, std::ios_base &, int &, long double &) const
#endif
#endif

#pragma do_not_instantiate std::istreambuf_iterator<char, std::char_traits<char> > std::num_get<char, std::istreambuf_iterator<char, std::char_traits<char> > >::do_get(std::istreambuf_iterator<char, std::char_traits<char> >, std::istreambuf_iterator<char, std::char_traits<char> >, std::ios_base &, int &, void *&) const
#pragma do_not_instantiate std::locale::id std::numpunct<char>::id 
#pragma do_not_instantiate std::locale::id std::num_get<char, std::istreambuf_iterator<char, std::char_traits<char> > >::id

#endif

#if defined(__VMS) && defined(__DECCXX) && !defined(__DECFIXCXXL1158)
#   pragma __extern_prefix __restore
#endif


#ifdef _RWSTD_COMPILE_INSTANTIATE
#include <numeral.cc>
#endif

#if defined(__DECCXX)
#   ifdef __PRAGMA_ENVIRONMENT
#      pragma __environment __restore
#   endif
#endif


#endif // __STD_NUMERAL__

