gccxml_gem 0.9.2-x86-mingw32

data/share/gccxml-0.9/Borland/5.5/rw/rwlocale.h

@@ -0,0 +1,619 @@
+#ifndef __RWLOCALE_H
+#define __RWLOCALE_H
+#pragma option push -b -a8 -pc -Vx- -Ve- -w-inl -w-aus -w-sig
+// -*- C++ -*-
+/***************************************************************************
+ *
+ * locale - Declarations for the Standard Library locale classes
+ *
+ ***************************************************************************
+ *
+ * Copyright (c) 1994-1999 Rogue Wave Software, Inc.  All Rights Reserved.
+ *
+ * This computer software is owned by Rogue Wave Software, Inc. and is
+ * protected by U.S. copyright laws and other laws and by international
+ * treaties.  This computer software is furnished by Rogue Wave Software,
+ * Inc. 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
+ * computer software or any other copies thereof may not be provided or
+ * otherwise made available to any other person.
+ *
+ * U.S. Government Restricted Rights.  This computer software is provided
+ * with Restricted Rights.  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 or subparagraphs (c) (1) and (2) of the
+ * Commercial Computer Software � Restricted Rights at 48 CFR 52.227-19,
+ * as applicable.  Manufacturer is Rogue Wave Software, Inc., 5500
+ * Flatiron Parkway, Boulder, Colorado 80301 USA.
+ *
+ **************************************************************************/
+
+#ifndef __STD_RWLOCALE__
+#define __STD_RWLOCALE__ 1
+
+#include <rw/rwstderr.h>
+
+#ifndef __STD_RWCOMPILER_H__
+#include <stdcomp.h>
+#endif
+
+#ifndef __STD_STRING__
+#include <string>
+#endif
+
+#ifndef __STD_IOSFWD__
+#include <iosfwd>
+#endif
+
+#ifndef _RWSTD_NO_NEW_HEADER
+#include <ctime>
+#else
+#include <time.h>
+#endif
+
+#ifndef _RWSTD_NO_BAD_CAST
+#include <typeinfo>
+#endif
+
+// In case these are (wrongly!) defined as macros in <cctype>.
+
+#undef isspace
+#undef isprint
+#undef iscntrl
+#undef isupper
+#undef islower
+#undef isalpha
+#undef isdigit
+#undef ispunct
+#undef isxdigit
+#undef isalnum
+#undef isgraph
+#undef toupper
+#undef tolower
+
+#ifndef _RWSTD_NO_NAMESPACE
+namespace __rwstd {
+#endif
+
+#ifdef _RWSTD_LOCALIZED_ERRORS
+  extern const unsigned int _RWSTDExport __rw_LocaleNotPresent;
+#else
+  extern const char _RWSTDExportFunc(*) __rw_LocaleNotPresent;
+#endif
+
+#ifndef _RWSTD_NO_NAMESPACE
+} namespace std {
+#endif
+
+// Forward declarations of functions and classes specified by the locale clause
+// of the C++ Standard Library working paper.
+
+class _RWSTDExport locale;
+
+#ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
+  template <class Facet> inline const Facet& use_facet (const locale&);
+  template <class Facet>
+    inline bool has_facet (const locale&) _RWSTD_THROW_SPEC_NULL;
+#else
+  template <class Facet>
+    _RWSTD_TRICKY_INLINE const Facet& use_facet (const locale&, Facet*);
+  template <class Facet>
+    inline bool has_facet (const locale&, Facet*) _RWSTD_THROW_SPEC_NULL;
+#endif // _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
+
+template <class charT> inline bool isspace  (charT c, const locale&);
+template <class charT> inline bool isprint  (charT c, const locale&);
+template <class charT> inline bool iscntrl  (charT c, const locale&);
+template <class charT> inline bool isupper  (charT c, const locale&);
+template <class charT> inline bool islower  (charT c, const locale&);
+template <class charT> inline bool isalpha  (charT c, const locale&);
+template <class charT> inline bool isdigit  (charT c, const locale&);
+template <class charT> inline bool ispunct  (charT c, const locale&);
+template <class charT> inline bool isxdigit (charT c, const locale&);
+template <class charT> inline bool isalnum  (charT c, const locale&);
+template <class charT> inline bool isgraph  (charT c, const locale&);
+
+template <class charT> inline charT toupper (charT c, const locale&);
+template <class charT> inline charT tolower (charT c, const locale&);
+
+class ctype_base;
+template <class charT> class ctype;
+_RWSTD_TEMPLATE class _RWSTDExport ctype<char>;
+template <class charT> class ctype_byname;
+_RWSTD_TEMPLATE class _RWSTDExport ctype_byname<char>;
+class codecvt_base;
+template  <class internT, class externT, class stateT> class codecvt;
+_RWSTD_TEMPLATE class _RWSTDExport codecvt<char,char,mbstate_t>;     // (imp)
+
+#ifndef _RWSTD_NO_WIDE_CHAR
+_RWSTD_TEMPLATE class _RWSTDExport ctype<wchar_t>;               // (imp)
+_RWSTD_TEMPLATE class _RWSTDExport ctype_byname<wchar_t>;
+_RWSTD_TEMPLATE class _RWSTDExport codecvt<wchar_t,char,mbstate_t>;  // (imp)
+#endif // _RWSTD_NO_WIDE_CHAR
+
+template <class internT, class externT, class stateT> class codecvt_byname;
+
+template <class charT,
+    class InputIterator _RWSTD_COMPLEX_DEFAULT(istreambuf_iterator<charT>)>
+    class num_get;
+template <class charT,
+    class OutputIterator _RWSTD_COMPLEX_DEFAULT(ostreambuf_iterator<charT>)>
+    class num_put;
+template <class charT> class numpunct;
+template <class charT> class numpunct_byname;
+
+template <class charT> class collate;
+template <class charT> class collate_byname;
+
+class time_base;
+template <class charT,
+    class InputIterator _RWSTD_COMPLEX_DEFAULT(istreambuf_iterator<charT>)>
+    class time_get;
+template <class charT,
+    class InputIterator _RWSTD_COMPLEX_DEFAULT(istreambuf_iterator<charT>)>
+    class time_get_byname;
+template <class charT,
+    class OutputIterator _RWSTD_COMPLEX_DEFAULT(ostreambuf_iterator<charT>)>
+    class time_put;
+template <class charT,
+    class OutputIterator _RWSTD_COMPLEX_DEFAULT(ostreambuf_iterator<charT>)>
+    class time_put_byname;
+
+class _RWSTDExport money_base;
+template <class charT,
+    class InputIterator _RWSTD_COMPLEX_DEFAULT(istreambuf_iterator<charT>)>
+    class money_get;
+template <class charT,
+    class OutputIterator _RWSTD_COMPLEX_DEFAULT(ostreambuf_iterator<charT>)>
+    class money_put;
+template <class charT, bool Intl _RWSTD_SIMPLE_DEFAULT(false)>
+    class moneypunct;
+template <class charT, bool Intl _RWSTD_SIMPLE_DEFAULT(false)>
+    class moneypunct_byname;
+
+class messages_base;
+template <class charT> class messages;
+template <class charT> class messages_byname;
+
+// Instantiations that go in the library:
+
+#if defined(__TURBOC__) && 0
+
+typedef istreambuf_iterator<char,char_traits<char> > __isit;
+typedef ostreambuf_iterator<char,char_traits<char> > __osit;
+
+template class _RWSTDExport codecvt_byname<char,char,mbstate_t>;
+template class _RWSTDExport num_get<char,__isit>;
+template class _RWSTDExport num_put<char,__osit>;
+template class _RWSTDExport numpunct<char>;
+template class _RWSTDExport numpunct_byname<char>;
+template class _RWSTDExport collate<char>;
+template class _RWSTDExport collate_byname<char>;
+template class _RWSTDExport time_get<char,__isit>;
+template class _RWSTDExport time_put<char,__osit>;
+template class _RWSTDExport money_get<char,__isit>;
+template class _RWSTDExport money_put<char,__osit>;
+template class _RWSTDExport moneypunct<char,false>;
+template class _RWSTDExport moneypunct<char,true>;
+template class _RWSTDExport moneypunct_byname<char,false>;
+template class _RWSTDExport moneypunct_byname<char,true>;
+template class _RWSTDExport messages<char>;
+template class _RWSTDExport messages_byname<char>;
+
+#ifndef _RWSTD_NO_WIDE_CHAR
+
+typedef istreambuf_iterator<wchar_t,char_traits<wchar_t> > __wisit;
+typedef ostreambuf_iterator<wchar_t,char_traits<wchar_t> > __wosit;
+
+template class _RWSTDExport codecvt_byname<wchar_t,wchar_t,mbstate_t>;
+template class _RWSTDExport num_get<wchar_t,__wisit>;
+template class _RWSTDExport num_put<wchar_t,__wosit>;
+template class _RWSTDExport numpunct<wchar_t>;
+template class _RWSTDExport numpunct_byname<wchar_t>;
+template class _RWSTDExport collate<wchar_t>;
+template class _RWSTDExport collate_byname<wchar_t>;
+template class _RWSTDExport time_get<wchar_t,__wisit>;
+template class _RWSTDExport time_put<wchar_t,__wosit>;
+template class _RWSTDExport money_get<wchar_t,__wisit>;
+template class _RWSTDExport money_put<wchar_t,__wosit>;
+template class _RWSTDExport moneypunct<wchar_t,false>;
+template class _RWSTDExport moneypunct<wchar_t,true>;
+template class _RWSTDExport moneypunct_byname<wchar_t,false>;
+template class _RWSTDExport moneypunct_byname<wchar_t,true>;
+template class _RWSTDExport messages<wchar_t>;
+template class _RWSTDExport messages_byname<wchar_t>;
+
+#endif // _RWSTD_NO_WIDE_CHAR
+
+#endif // __TURBOC__
+
+#ifndef _RWSTD_NO_NAMESPACE
+} // namespace std
+#endif
+
+#ifndef __STD_RW_LOCIMPL__
+#include <rw/locimpl>
+#endif
+
+#ifndef _RWSTD_NO_NAMESPACE
+namespace std {
+#endif
+
+// -------------
+// Class locale.
+// -------------
+
+class _RWSTDExport locale {
+ public:
+  class facet;
+  class id;
+
+  friend class facet;
+  friend class id;
+
+  typedef int category;
+
+  // The following constants identify standard categories of facets.  The
+  // standard specifies them as const members of type category (i.e. as const
+  // ints).  For compilers that can't initialize const members here, we define
+  // them as members of an anonymous enum instead.
+
+  // Some compilers get confused by the name collision of these constants with
+  // the facet templates collate, ctype and messages.  As a work-around, we
+  // also define non-standard names of the form __rw_xxx_category for these
+  // three categories.  If you have one of the confused compilers (i.e. if
+  // _RWSTD_CONFUSED_ENUM_SCOPE is #defined for you), you must use these non-
+  // standard category names.
+
+  #ifndef _RWSTD_CONFUSED_ENUM_SCOPE
+  #define _RWSTD_CATEGORY_NAMES                             \
+    collate = 0x0010, ctype = 0x0020, monetary = 0x0040,    \
+    numeric = 0x0080, time  = 0x0100, messages = 0x0200,    \
+    all     = 0x03f0, none  = 0x0000
+  #else
+  #define _RWSTD_CATEGORY_NAMES                             \
+    monetary = 0x0040, numeric = 0x0080, time  = 0x0100,    \
+    all      = 0x03f0, none  = 0x0000
+  #endif
+
+  #define _RWSTD_IMPLEMENTATION_VALS                                  \
+    __rw_collate_category  = 0x0010, __rw_ctype_category    = 0x0020, \
+    __rw_messages_category = 0x0200, __rw_Clib_LC_constants = 0x000F, \
+    __rw_num_categories    = 6,      __rw_first_category    = 0x0010
+
+  #ifndef _RWSTD_NO_STI_SIMPLE
+  static const category _RWSTD_CATEGORY_NAMES, _RWSTD_IMPLEMENTATION_VALS;
+  #else
+  enum { _RWSTD_CATEGORY_NAMES, _RWSTD_IMPLEMENTATION_VALS };
+  #endif
+
+  #undef _RWSTD_CATEGORY_NAMES
+  #undef _RWSTD_IMPLEMENTATION_VALS
+
+  // The default constructor creates a copy of the current global locale.
+  // This is the locale specified in the most recent call to locale::global().
+  // If locale::global() has not been called, it is the classic "C" locale.
+
+  inline locale () _RWSTD_THROW_SPEC_NULL;
+
+  // The copy constructor (and the assignment operator, below) can be used
+  // freely.  Like a string, most of a locale's contents are in a separate,
+  // reference-counted implementation object, so copying and assigning locales
+  // has little overhead.
+
+  inline locale (const locale& other) _RWSTD_THROW_SPEC_NULL;
+
+  // The following constructor creates a locale composed of by-name facets and
+  // assigns it a name.  The valid arguments are "", "C", and a set of strings
+  // defined by the compiler vendor.  These cause the facets of the locale to
+  // be obtained, respectively, from the user's preferred locale, from the
+  // classic locale, or from the compiler's locale database.  (In many cases,
+  // the preferred locale is specified by environment variables such as LANG
+  // or LC_ALL.)  If the argument is not recognized, the constructor throws
+  // runtime_error.
+
+  _EXPLICIT locale (const char* name);
+
+  // The following constructor copies its first argument except for the facets
+  // in the categories identified by the third argument, which are obtained by
+  // name using the second argument.  Can throw runtime_error.
+
+  locale (const locale& other, const char* name, category);
+
+  // The following templatized constructor is only available if your compiler
+  // supports member function templates.  It copies its first argument except
+  // the single facet of type Facet, which it gets from the second argument.
+
+  #ifndef _RWSTD_NO_MEMBER_TEMPLATES
+
+  template <class Facet>
+  inline locale (const locale& other,Facet* f);
+
+  #else
+
+  // If your compiler does not support member function templates, we provide
+  // the following work-around to let you accrete facets onto a locale.  This
+  // constructor copies its first argument except for the single facet of the
+  // type of the second argument, for which it uses the second argument.
+  //
+  // To determine the type of the second argument, it calls the non-standard
+  // virtual method __get_id in the second argument.  If you are creating your
+  // own facet types on a compiler that does not support member templates, you
+  // must code a __get_id member as follows in each new base class facet (i.e.
+  // in each facet class that has its own static member id of type locale::id):
+  //
+  //    virtual locale::id &__get_id (void) const { return id; }
+  //
+  // See the __get_id members in the standard facets below for examples.
+
+  inline locale (const locale& other, facet* f);
+
+  #endif // _RWSTD_NO_MEMBER_TEMPLATES
+
+  // The following constructor copies its first argument except for the facets
+  // in the categories identified by the third argument, which are obtained
+  // from the second argument.
+
+  locale (const locale &other, const locale &second, category);
+
+  // The destructor is non-virtual.  Other classes are not supposed to be
+  // derived from locale.
+
+  ~locale ()
+  {
+    __RWSTD::ref_counted::remove_reference(__imp);
+  }
+
+  const locale& operator = (const locale& other) _RWSTD_THROW_SPEC_NULL;
+
+  // The following member function template is available only if your compiler
+  // supports member templates that are templatized on types that don't appear
+  // in the argument list.  It returns a copy of this locale (*this) except
+  // the single facet of type Facet, which it gets from the other locale.
+
+  #ifndef _RWSTD_NO_MEMBER_TEMPLATES
+  #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
+  template <class Facet>
+  inline locale combine (const locale& other) const;
+  #endif // _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
+  #endif // _RWSTD_NO_MEMBER_TEMPLATES
+
+  // The following returns the locale name, or "*" if the locale is unnamed.
+
+  string name () const;
+
+  // Two locales are equal if they are the same object, or one is a copy of the
+  // other (i.e. they have the same implementation object), or both are named
+  // and their names are the same.
+
+  bool operator == (const locale& other) const;
+  bool operator != (const locale& other) const { return !(*this==other); }
+
+  // The following templatized operator () satisfies STL requirements for a
+  // comparator predicate template argument for comparing strings according to
+  // the collating sequence of the locale.  It lets you use a locale directly
+  // as a comparator using syntax like sort(v.begin(),v.end(),loc), where v is
+  // a vector of some string type and loc is a locale.  If your compiler does
+  // not support member function templates, we provide explicit support for
+  // string and (if applicable) wstring.
+
+  #ifndef _RWSTD_NO_MEMBER_TEMPLATES
+  template <class charT, class Traits, class Allocator>
+  bool operator() (const basic_string<charT,Traits,Allocator>& s1,
+                   const basic_string<charT,Traits,Allocator>& s2) const;
+  #else
+  bool operator() (const string &s1,const string &s2) const;
+  #ifndef _RWSTD_NO_WIDE_CHAR
+  bool operator() (const wstring &s1,const wstring &s2) const;
+  #endif
+  #endif
+
+  // Static members.
+
+  static locale global (const locale&);  // Replaces the current global locale
+  static const locale &classic ();       // Returns the classic "C" locale
+
+  // class facet -- base class for locale feature sets.
+
+  // Any class deriving from facet that wants to be perceived as a distinct
+  // facet, as opposed to a re-implementation of an existing facet, must
+  // declare a static member: static std::locale::id id;
+
+  class facet: public __RWSTD::facet_imp {
+    friend class __RWSTD::locale_imp;
+    friend class locale;
+   protected:
+    _EXPLICIT facet (size_t refs=0,int cat=0):
+        __RWSTD::facet_imp(refs,cat) { }
+
+    virtual ~facet() { }
+
+    #ifdef _RWSTD_NO_MEMBER_TEMPLATES
+    virtual id &__get_id (void) const=0;
+    #endif
+
+   private:
+    facet (const facet&);           // not defined
+    void operator = (const facet&); // not defined
+  };
+
+  // class id -- facet type identifier.
+
+  // This is mostly an implementation class.  It is used internally as an index
+  // to find facets within a locale.  Each distinct facet (i.e. each T that can
+  // be the parameter of a use_facet<T> call) has a unique static member of type
+  // locale::id named id.  The class is made public to enable extension of the
+  // set of standard facets.  Objects of this type don't need to be constructed
+  // or referenced in any other circumstances.
+
+  class id: private __RWSTD::locale_id_imp {
+    _RWSTD_FRIEND_USE_HAS_FACET
+    friend class locale;
+#if defined ( _MSC_VER ) || defined (__TURBOC__)
+   public:
+#endif
+#ifdef _HPACC_
+    operator size_t () const { return __RWSTD::locale_id_imp::__id_value; }
+#else
+    operator size_t () const { return __id_value; }
+#endif
+
+    // The private copy constructor and assignment operator help restrict the
+    // class to its intended use.  The copy constructor prevents the compiler
+    // from generating a do-nothing default constructor, so we provide one.
+    // We omit the constructors on compilers that don't support static template
+    // members with constructors.
+
+#ifndef _RWSTD_NO_STATIC_DEF3
+   public:
+    id () { }
+   private:
+    id (const id&);
+#endif
+   private:
+    void operator = (const id&);
+  };
+
+ private:
+
+  // Implementation.
+  friend class __RWSTD::locale_imp;
+  _RWSTD_FRIEND_USE_HAS_FACET
+
+#if defined ( _MSC_VER ) || defined (__TURBOC__)
+ public:
+#endif
+
+  // The only data member is a pointer to a ref-counted implementation object:
+  __RWSTD::locale_imp *__imp;
+
+  // Typedef for the implementation-defined call-back functions that must be
+  // passed to __make_explicit (below).
+  typedef __RWSTD::facet_maker_func __facet_maker_func;
+
+  // The following function retrieves an implicit facet from a cache,
+  // or creates one if needed (via call to the passed call-back
+  // function), and makes it an explicit facet of the locale.
+
+  __RWSTD::facet_imp * __make_explicit (const id &facet_id, bool ok_implicit,
+       category facet_cat, __facet_maker_func maker) const;
+
+  inline __RWSTD::facet_imp *get_facet (size_t) const;
+
+#if defined(_MSC_VER) && !defined(__BORLANDC__)
+ private:
+#endif
+
+  void __install (__RWSTD::facet_imp *f, const id& i) const;
+
+  static __RWSTD::locale_imp *__the_classic_locale;
+  static __RWSTD::locale_imp *__the_native_locale;
+  static __RWSTD::locale_imp *__global;
+
+  // Construct a locale from an implementation object.
+  inline _EXPLICIT locale (__RWSTD::locale_imp *m);
+
+ private:
+  // We have to say private again in case _RWSTD_FRIEND_USE_HAS_FACET evaluated
+  // to public:
+
+  // Create initial implementation objects.
+  static void init ();
+};
+
+#undef _RWSTD_FRIEND_USE_HAS_FACET
+
+// ----------------------------
+// Class locale inline members.
+// ----------------------------
+
+// Private constructor for use by implementation, constructs a locale from
+// a locale_imp implementation object.
+inline locale::locale (__RWSTD::locale_imp *m): __imp(m) {
+  if (!__global) init();
+  __RWSTD::ref_counted::add_reference(__imp);
+}
+
+// Default constructor, returns a copy of the current global locale.
+inline locale::locale () _RWSTD_THROW_SPEC_NULL {
+  if (!__global) init(); // This is not throw() ... something has to give.
+  __RWSTD::ref_counted::add_reference(__imp=__global);
+}
+
+// Copy constructor.
+inline locale::locale (const locale& other) _RWSTD_THROW_SPEC_NULL {
+  __RWSTD::ref_counted::add_reference(__imp=other.__imp);
+}
+
+#ifndef _RWSTD_NO_MEMBER_TEMPLATES
+
+// Constructor to accrete or replace a single facet.
+template <class Facet>
+inline locale::locale (const locale& other, Facet* f)
+{
+  if (f) {
+    __imp=new __RWSTD::locale_imp (*other.__imp,1);
+    __install(f,Facet::id);
+    __imp->named_=false;
+  } else
+    __RWSTD::ref_counted::add_reference(__imp=other.__imp);
+}
+
+#ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
+
+template <class Facet>
+inline locale locale::combine (const locale& other) const
+{
+  return locale (*this,&use_facet<Facet>(other));
+}
+
+#endif /* _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE */
+
+#else
+
+inline locale::locale (const locale& other, facet* f):
+    __imp(new __RWSTD::locale_imp (*other.__imp,1))
+{
+  __install(f,f->__get_id());
+  __imp->named_=false;
+}
+
+#endif // _RWSTD_NO_MEMBER_TEMPLATES
+// Private implementation helper function.
+inline __RWSTD::facet_imp* locale::get_facet (size_t i) const {
+  return __imp->get_facet(i);
+}
+
+#ifndef _RWSTD_NO_NAMESPACE
+} namespace __rwstd {
+#endif
+// -------------------------------------------------------
+// Implementation function template -- create_named_facet.
+// -------------------------------------------------------
+// 
+// The default for facets with no derived byname version is to create a facet
+// with classic ("C") behavior, ignoring the passed name.
+
+template <class Facet>
+inline Facet* create_named_facet (Facet*,const char* /* name */ ,size_t refs)
+{
+  return new Facet(refs);
+}
+
+#ifndef _RWSTD_NO_NAMESPACE
+} // namespace __rwstd
+#endif
+
+// Get declarations for vendor-defined extensions, such as 
+// declarations of the facets of the native ("") locale.
+#include <rw/vendor>
+
+#ifdef _RWSTD_NO_TEMPLATE_REPOSITORY
+#include <rw/rwlocale.cc>
+#endif
+
+#endif // __STD_RWLOCALE__
+#pragma option pop
+#endif /* __RWLOCALE_H */

data/share/gccxml-0.9/Borland/5.5/stdarg.h

@@ -0,0 +1,55 @@
+/*  stdarg.h
+
+    Definitions for accessing parameters in functions that accept
+    a variable number of arguments.
+
+*/
+
+/*
+ *      C/C++ Run Time Library - Version 10.0
+ *
+ *      Copyright (c) 1987, 2000 by Inprise Corporation
+ *      All Rights Reserved.
+ *
+ */
+
+/* $Revision: 1.1 $ */
+
+#ifndef __STDARG_H
+#define __STDARG_H
+#define _INC_STDARG  /* MSC Guard name */
+
+#ifdef __VARARGS_H
+#error Cannot include both STDARG.H and VARARGS.H
+#endif
+
+#ifndef ___STDDEF_H
+#include <_stddef.h>
+#endif
+
+#ifdef __cplusplus
+namespace std {
+#endif /* __cplusplus */
+
+typedef void _FAR *va_list;
+
+#define __size(x) ((sizeof(x)+sizeof(int)-1) & ~(sizeof(int)-1))
+
+#define va_start(ap, parmN) ((void)((ap) = (va_list)((char _FAR *)(&parmN)+__size(parmN))))
+#define va_arg(ap, type) (*(type _FAR *)(((*(char _FAR *_FAR *)&(ap))+=__size(type))-(__size(type))))
+#define va_end(ap)          ((void)0)
+
+#if !defined(__STDC__)
+#define _va_ptr             (...)
+#endif
+
+#ifdef __cplusplus
+} // std
+#endif /* __cplusplus */
+
+#endif  /* __STDARG_H */
+
+#if defined(__cplusplus) && !defined(__USING_CNAME__) && !defined(__STDARG_H_USING_LIST)
+#define __STDARG_H_USING_LIST
+     using std::va_list;
+#endif /* __USING_CNAME__ */